1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package net.sourceforge.pmd.lang.plsql.ast;
21
22 import java.io.*;
23 import net.sourceforge.pmd.lang.ast.Node;
24 import net.sourceforge.pmd.lang.ast.SimpleCharStream;
25 import net.sourceforge.pmd.lang.ast.TokenMgrError;
26
27 public class PLSQLParser
28 protected JJTPLSQLParserState jjtree = new JJTPLSQLParserState();
29
30
31
32
33 public static void main(String[] args)
34 throws ParseException {
35
36 PLSQLParser parser = new PLSQLParser(System.in);
37 PLSQLNode node = parser.Input();
38
39 String s;
40 s = "qwerty";
41
42 s = "\u005c"qwerty\u005c"";
43
44 s = "\u005c"qwerty\u005c".uiop";
45
46 s = "\u005c"qwerty\u005c".\u005c"uiop\u005c"";
47
48 }
49
50
51
52
53 public static String canonicalName(String name)
54 {
55 StringBuilder s = null ;
56
57
58 if (null == name) {
59 return name;
60 }
61 else if (-1 == name.indexOf('"') )
62 {
63 name = name.toUpperCase();
64 s = new StringBuilder(name.trim());
65 }
66 else
67 {
68 StringBuilder oldString = new StringBuilder( name.trim().length());
69 s = new StringBuilder(name.trim());
70 boolean quotedCharacter = false ;
71 for (int i=0; i<oldString.length(); i++) {
72 if (oldString.charAt(i) == '"')
73 {
74
75 oldString.deleteCharAt(i);
76 i--;
77
78
79 quotedCharacter = !quotedCharacter ;
80 }
81 else
82 {
83 s.append( quotedCharacter
84 ? s.charAt(i)
85 : Character.toUpperCase(s.charAt(i))
86 );
87 }
88 }
89 }
90 return s.toString();
91 }
92
93
94
95
96
97
98
99
100
101
102
103 final public ASTInput Input() throws ParseException {
104
105 ASTInput jjtn000 = new ASTInput(this, JJTINPUT);
106 boolean jjtc000 = true;
107 jjtree.openNodeScope(jjtn000);
108 try {
109 label_1:
110 while (true) {
111 switch (jj_nt.kind) {
112 case 2:
113 case 3:
114 case 21:
115 case ALTER:
116 case BEGIN:
117 case COLUMN:
118 case COMMENT:
119 case COMMIT:
120 case CONNECT:
121 case CREATE:
122 case DECLARE:
123 case DELETE:
124 case DROP:
125 case EXECUTE:
126 case EXIT:
127 case FUNCTION:
128 case GRANT:
129 case INSERT:
130 case LOCK:
131 case MERGE:
132 case PACKAGE:
133 case PROMPT:
134 case PROCEDURE:
135 case RENAME:
136 case REVOKE:
137 case ROLLBACK:
138 case SAVEPOINT:
139 case SELECT:
140 case SET:
141 case START:
142 case TRIGGER:
143 case TYPE:
144 case SHOW:
145 case SPOOL:
146 case UPDATE:
147 case WITH:
148 case ANALYZE:
149 case ASSOCIATE:
150 case AUDIT:
151 case DDL:
152 case DISASSOCIATE:
153 case NOAUDIT:
154 case TRUNCATE:
155 case ACCEPT:
156 case COPY:
157 case DEFINE:
158 case DISCONNECT:
159 case HOST:
160 case PRINT:
161 case QUIT:
162 case REMARK:
163 case UNDEFINE:
164 case VARIABLE:
165 case WHENEVER:
166 case IDENTIFIER:
167 ;
168 break;
169 default:
170 jj_la1[0] = jj_gen;
171 break label_1;
172 }
173 if (jj_2_1(6)) {
174 PackageSpecification();
175 } else if (jj_2_2(6)) {
176 PackageBody();
177 } else if (jj_2_3(6)) {
178 TypeSpecification();
179 } else if (jj_2_4(6)) {
180 Table();
181 } else if (jj_2_5(6)) {
182 View();
183 } else if (jj_2_6(6)) {
184 TriggerUnit();
185 } else if (jj_2_7(6)) {
186 AlterTrigger();
187 } else if (jj_2_8(6)) {
188 Synonym();
189 } else if (jj_2_9(6)) {
190 Directory();
191 } else if (jj_2_10(6)) {
192 DatabaseLink();
193 } else if (jj_2_11(6)) {
194 Global();
195 } else if (jj_2_12(6)) {
196 DDLCommand();
197 } else if (jj_2_13(2)) {
198 SqlPlusCommand();
199 } else {
200 switch (jj_nt.kind) {
201 case COMMIT:
202 case DELETE:
203 case INSERT:
204 case LOCK:
205 case MERGE:
206 case ROLLBACK:
207 case SAVEPOINT:
208 case SELECT:
209 case UPDATE:
210 case WITH:
211 switch (jj_nt.kind) {
212 case SELECT:
213 jj_consume_token(SELECT);
214 break;
215 case UPDATE:
216 jj_consume_token(UPDATE);
217 break;
218 case INSERT:
219 jj_consume_token(INSERT);
220 break;
221 case DELETE:
222 jj_consume_token(DELETE);
223 break;
224 case COMMIT:
225 jj_consume_token(COMMIT);
226 break;
227 case ROLLBACK:
228 jj_consume_token(ROLLBACK);
229 break;
230 case SAVEPOINT:
231 jj_consume_token(SAVEPOINT);
232 break;
233 case LOCK:
234 jj_consume_token(LOCK);
235 jj_consume_token(TABLE);
236 break;
237 case MERGE:
238 jj_consume_token(MERGE);
239 break;
240 case WITH:
241 jj_consume_token(WITH);
242 break;
243 default:
244 jj_la1[1] = jj_gen;
245 jj_consume_token(-1);
246 throw new ParseException();
247 }
248 SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
249 break;
250 default:
251 jj_la1[2] = jj_gen;
252 jj_consume_token(-1);
253 throw new ParseException();
254 }
255 }
256 label_2:
257 while (true) {
258 switch (jj_nt.kind) {
259 case 1:
260 ;
261 break;
262 default:
263 jj_la1[3] = jj_gen;
264 break label_2;
265 }
266 jj_consume_token(1);
267 }
268 }
269 jj_consume_token(0);
270 jjtree.closeNodeScope(jjtn000, true);
271 jjtc000 = false;
272 {if (true) return jjtn000 ;}
273 } catch (Throwable jjte000) {
274 if (jjtc000) {
275 jjtree.clearNodeScope(jjtn000);
276 jjtc000 = false;
277 } else {
278 jjtree.popNode();
279 }
280 if (jjte000 instanceof RuntimeException) {
281 {if (true) throw (RuntimeException)jjte000;}
282 }
283 if (jjte000 instanceof ParseException) {
284 {if (true) throw (ParseException)jjte000;}
285 }
286 {if (true) throw (Error)jjte000;}
287 } finally {
288 if (jjtc000) {
289 jjtree.closeNodeScope(jjtn000, true);
290 }
291 }
292 throw new Error("Missing return statement in function");
293 }
294
295 final public ASTDDLCommand DDLCommand() throws ParseException {
296
297 ASTDDLCommand jjtn000 = new ASTDDLCommand(this, JJTDDLCOMMAND);
298 boolean jjtc000 = true;
299 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
300 try {
301 simpleNode = DDLEvent();
302 SkipPastNextTokenOccurrence(SQLPLUS_TERMINATOR);
303 jjtree.closeNodeScope(jjtn000, true);
304 jjtc000 = false;
305 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
306 } catch (Throwable jjte000) {
307 if (jjtc000) {
308 jjtree.clearNodeScope(jjtn000);
309 jjtc000 = false;
310 } else {
311 jjtree.popNode();
312 }
313 if (jjte000 instanceof RuntimeException) {
314 {if (true) throw (RuntimeException)jjte000;}
315 }
316 if (jjte000 instanceof ParseException) {
317 {if (true) throw (ParseException)jjte000;}
318 }
319 {if (true) throw (Error)jjte000;}
320 } finally {
321 if (jjtc000) {
322 jjtree.closeNodeScope(jjtn000, true);
323 }
324 }
325 throw new Error("Missing return statement in function");
326 }
327
328 final public ASTSqlPlusCommand SqlPlusCommand() throws ParseException {
329
330 ASTSqlPlusCommand jjtn000 = new ASTSqlPlusCommand(this, JJTSQLPLUSCOMMAND);
331 boolean jjtc000 = true;
332 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder() ;
333 try {
334 switch (jj_nt.kind) {
335 case 2:
336 jj_consume_token(2);
337 break;
338 case ACCEPT:
339 jj_consume_token(ACCEPT);
340 break;
341 case COLUMN:
342 jj_consume_token(COLUMN);
343 break;
344 case CONNECT:
345 jj_consume_token(CONNECT);
346 break;
347 case COPY:
348 jj_consume_token(COPY);
349 break;
350 case DEFINE:
351 jj_consume_token(DEFINE);
352 break;
353 case DISCONNECT:
354 jj_consume_token(DISCONNECT);
355 break;
356 case EXECUTE:
357 jj_consume_token(EXECUTE);
358 break;
359 case EXIT:
360 jj_consume_token(EXIT);
361 break;
362 case HOST:
363 jj_consume_token(HOST);
364 break;
365 case PRINT:
366 jj_consume_token(PRINT);
367 break;
368 case PROMPT:
369 jj_consume_token(PROMPT);
370 break;
371 case QUIT:
372 jj_consume_token(QUIT);
373 break;
374 case REMARK:
375 jj_consume_token(REMARK);
376 break;
377 case SET:
378 jj_consume_token(SET);
379 break;
380 case SHOW:
381 jj_consume_token(SHOW);
382 break;
383 case SPOOL:
384 jj_consume_token(SPOOL);
385 break;
386 case START:
387 jj_consume_token(START);
388 break;
389 case UNDEFINE:
390 jj_consume_token(UNDEFINE);
391 break;
392 case VARIABLE:
393 jj_consume_token(VARIABLE);
394 break;
395 case WHENEVER:
396 jj_consume_token(WHENEVER);
397 break;
398 case COMMENT:
399 jj_consume_token(COMMENT);
400 break;
401 case GRANT:
402 jj_consume_token(GRANT);
403 break;
404 case REVOKE:
405 jj_consume_token(REVOKE);
406 break;
407 case DROP:
408 jj_consume_token(DROP);
409 break;
410 case IDENTIFIER:
411 jj_consume_token(IDENTIFIER);
412 break;
413 case 3:
414 jj_consume_token(3);
415 jj_consume_token(ATTACH);
416 break;
417 default:
418 jj_la1[4] = jj_gen;
419 jj_consume_token(-1);
420 throw new ParseException();
421 }
422 sb.append(token.image) ; sb.append(" ...") ;
423 Skip2NextTokenOccurrence(EOL);
424 jjtree.closeNodeScope(jjtn000, true);
425 jjtc000 = false;
426 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
427 } catch (Throwable jjte000) {
428 if (jjtc000) {
429 jjtree.clearNodeScope(jjtn000);
430 jjtc000 = false;
431 } else {
432 jjtree.popNode();
433 }
434 if (jjte000 instanceof RuntimeException) {
435 {if (true) throw (RuntimeException)jjte000;}
436 }
437 if (jjte000 instanceof ParseException) {
438 {if (true) throw (ParseException)jjte000;}
439 }
440 {if (true) throw (Error)jjte000;}
441 } finally {
442 if (jjtc000) {
443 jjtree.closeNodeScope(jjtn000, true);
444 }
445 }
446 throw new Error("Missing return statement in function");
447 }
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474 final public ASTGlobal Global() throws ParseException {
475
476 ASTGlobal jjtn000 = new ASTGlobal(this, JJTGLOBAL);
477 boolean jjtc000 = true;
478 jjtree.openNodeScope(jjtn000);
479 try {
480 if (jj_2_14(2147483647)) {
481 label_3:
482 while (true) {
483 switch (jj_nt.kind) {
484 case 21:
485 ;
486 break;
487 default:
488 jj_la1[5] = jj_gen;
489 break label_3;
490 }
491 Label();
492 }
493 Block();
494 jj_consume_token(4);
495 } else if (jj_2_15(4)) {
496 ProgramUnit();
497 } else {
498 jj_consume_token(-1);
499 throw new ParseException();
500 }
501 jjtree.closeNodeScope(jjtn000, true);
502 jjtc000 = false;
503 {if (true) return jjtn000 ;}
504 } catch (Throwable jjte000) {
505 if (jjtc000) {
506 jjtree.clearNodeScope(jjtn000);
507 jjtc000 = false;
508 } else {
509 jjtree.popNode();
510 }
511 if (jjte000 instanceof RuntimeException) {
512 {if (true) throw (RuntimeException)jjte000;}
513 }
514 if (jjte000 instanceof ParseException) {
515 {if (true) throw (ParseException)jjte000;}
516 }
517 {if (true) throw (Error)jjte000;}
518 } finally {
519 if (jjtc000) {
520 jjtree.closeNodeScope(jjtn000, true);
521 }
522 }
523 throw new Error("Missing return statement in function");
524 }
525
526 final public ASTBlock Block() throws ParseException {
527
528 ASTBlock jjtn000 = new ASTBlock(this, JJTBLOCK);
529 boolean jjtc000 = true;
530 jjtree.openNodeScope(jjtn000);
531 try {
532 switch (jj_nt.kind) {
533 case DECLARE:
534 jj_consume_token(DECLARE);
535 DeclarativeSection();
536 break;
537 default:
538 jj_la1[6] = jj_gen;
539 ;
540 }
541 jj_consume_token(BEGIN);
542 label_4:
543 while (true) {
544 switch (jj_nt.kind) {
545 case 5:
546 case 16:
547 case 17:
548 case 21:
549 case REPLACE:
550 case DEFINER:
551 case CURRENT_USER:
552 case LANGUAGE:
553 case ADD:
554 case AGGREGATE:
555 case ARRAY:
556 case AT:
557 case ATTRIBUTE:
558 case AUTHID:
559 case BEGIN:
560 case BODY:
561 case BULK:
562 case BYTE:
563 case CASCADE:
564 case CASE:
565 case CLOSE:
566 case COALESCE:
567 case COLLECT:
568 case COLUMN:
569 case COMMENT:
570 case COMMIT:
571 case CONSTRUCTOR:
572 case CONTINUE:
573 case CONVERT:
574 case CURRENT:
575 case CURSOR:
576 case DATA:
577 case DATE:
578 case DAY:
579 case DECLARE:
580 case DELETE:
581 case DISABLE:
582 case EDITIONABLE:
583 case ELEMENT:
584 case ENABLE:
585 case ESCAPE:
586 case EXCEPT:
587 case EXCEPTIONS:
588 case EXECUTE:
589 case EXIT:
590 case EXTERNAL:
591 case EXTENDS:
592 case EXTRACT:
593 case FALSE:
594 case FETCH:
595 case FINAL:
596 case FOR:
597 case FORALL:
598 case FORCE:
599 case FUNCTION:
600 case GLOBAL:
601 case GOTO:
602 case HASH:
603 case HEAP:
604 case HOUR:
605 case IF:
606 case IMMEDIATE:
607 case INDICES:
608 case INDEXTYPE:
609 case INDICATOR:
610 case INSERT:
611 case INSTANTIABLE:
612 case INTERVAL:
613 case INVALIDATE:
614 case ISOLATION:
615 case JAVA:
616 case LEVEL:
617 case LIMIT:
618 case LOCK:
619 case LOOP:
620 case MAP:
621 case MAX:
622 case MEMBER:
623 case MERGE:
624 case MIN:
625 case MINUTE:
626 case MLSLABEL:
627 case MODIFY:
628 case MOD:
629 case MONTH:
630 case NATURAL:
631 case NEW:
632 case NEW_DOT:
633 case NO:
634 case NONEDITIONABLE:
635 case NOT:
636 case NULL:
637 case NULLIF:
638 case OBJECT:
639 case OID:
640 case OPAQUE:
641 case OPEN:
642 case OPERATOR:
643 case ORGANIZATION:
644 case OTHERS:
645 case OVERRIDING:
646 case PACKAGE:
647 case PARTITION:
648 case PIPE:
649 case PRESERVE:
650 case PRIVATE:
651 case PROCEDURE:
652 case RAISE:
653 case RANGE:
654 case RAW:
655 case REAL:
656 case RECORD:
657 case REF:
658 case RELEASE:
659 case RELIES_ON:
660 case RENAME:
661 case RESULT:
662 case RETURN:
663 case RETURNING:
664 case REVERSE:
665 case ROLLBACK:
666 case ROW:
667 case ROWS:
668 case ROWID:
669 case ROWNUM:
670 case SAVE:
671 case SAVEPOINT:
672 case SECOND:
673 case SELECT:
674 case SELF:
675 case SET:
676 case SPACE:
677 case SQL:
678 case SQLCODE:
679 case SQLERRM:
680 case STATIC:
681 case SUBTYPE:
682 case SUBSTITUTABLE:
683 case SUCCESSFUL:
684 case SYSDATE:
685 case SYS_REFCURSOR:
686 case TEMPORARY:
687 case TIME:
688 case TIMESTAMP:
689 case TIMEZONE_REGION:
690 case TIMEZONE_ABBR:
691 case TIMEZONE_MINUTE:
692 case TIMEZONE_HOUR:
693 case TRANSACTION:
694 case TRUE:
695 case TYPE:
696 case UNDER:
697 case USING:
698 case WHILE:
699 case YES:
700 case SHOW:
701 case A:
702 case UPDATE:
703 case DOUBLE:
704 case DEC:
705 case PRECISION:
706 case INT:
707 case NUMERIC:
708 case NCHAR:
709 case NVARCHAR2:
710 case STRING:
711 case UROWID:
712 case VARRAY:
713 case VARYING:
714 case BFILE:
715 case BLOB:
716 case CLOB:
717 case NCLOB:
718 case YEAR:
719 case LOCAL:
720 case WITH:
721 case ZONE:
722 case CHARACTER:
723 case AFTER:
724 case BEFORE:
725 case OLD:
726 case PARENT:
727 case CC_IF:
728 case CC_ERROR:
729 case ANALYZE:
730 case ASSOCIATE:
731 case AUDIT:
732 case COMPOUND:
733 case DATABASE:
734 case CALL:
735 case DDL:
736 case DISASSOCIATE:
737 case EACH:
738 case FOLLOWS:
739 case LOGOFF:
740 case LOGON:
741 case NESTED:
742 case NOAUDIT:
743 case SCHEMA:
744 case SERVERERROR:
745 case SHUTDOWN:
746 case STARTUP:
747 case STATEMENT:
748 case STATISTICS:
749 case SUSPEND:
750 case TRUNCATE:
751 case WRAPPED:
752 case LIBRARY:
753 case NAME:
754 case STRUCT:
755 case CONTEXT:
756 case PARAMETERS:
757 case LENGTH:
758 case TDO:
759 case MAXLEN:
760 case CHARSETID:
761 case CHARSETFORM:
762 case ACCEPT:
763 case ACCESSIBLE:
764 case COPY:
765 case DEFINE:
766 case DISCONNECT:
767 case HOST:
768 case PRINT:
769 case QUIT:
770 case REMARK:
771 case UNDEFINE:
772 case VARIABLE:
773 case WHENEVER:
774 case ATTACH:
775 case CAST:
776 case TREAT:
777 case TRIM:
778 case LEFT:
779 case RIGHT:
780 case BOTH:
781 case EMPTY:
782 case MULTISET:
783 case SUBMULTISET:
784 case LEADING:
785 case TRAILING:
786 case CHAR_CS:
787 case NCHAR_CS:
788 case DBTIMEZONE:
789 case SESSIONTIMEZONE:
790 case AUTHENTICATED:
791 case LINK:
792 case SHARED:
793 case DIRECTORY:
794 case USER:
795 case IDENTIFIER:
796 case UNSIGNED_NUMERIC_LITERAL:
797 case CHARACTER_LITERAL:
798 case STRING_LITERAL:
799 case QUOTED_LITERAL:
800 ;
801 break;
802 default:
803 jj_la1[7] = jj_gen;
804 break label_4;
805 }
806 Statement();
807 }
808 switch (jj_nt.kind) {
809 case EXCEPTION:
810 ExceptionHandler();
811 break;
812 default:
813 jj_la1[8] = jj_gen;
814 ;
815 }
816 jj_consume_token(END);
817 switch (jj_nt.kind) {
818 case IDENTIFIER:
819 jj_consume_token(IDENTIFIER);
820 break;
821 default:
822 jj_la1[9] = jj_gen;
823 ;
824 }
825 jjtree.closeNodeScope(jjtn000, true);
826 jjtc000 = false;
827 {if (true) return jjtn000 ;}
828 } catch (Throwable jjte000) {
829 if (jjtc000) {
830 jjtree.clearNodeScope(jjtn000);
831 jjtc000 = false;
832 } else {
833 jjtree.popNode();
834 }
835 if (jjte000 instanceof RuntimeException) {
836 {if (true) throw (RuntimeException)jjte000;}
837 }
838 if (jjte000 instanceof ParseException) {
839 {if (true) throw (ParseException)jjte000;}
840 }
841 {if (true) throw (Error)jjte000;}
842 } finally {
843 if (jjtc000) {
844 jjtree.closeNodeScope(jjtn000, true);
845 }
846 }
847 throw new Error("Missing return statement in function");
848 }
849
850 final public ASTPackageSpecification PackageSpecification() throws ParseException {
851
852 ASTPackageSpecification jjtn000 = new ASTPackageSpecification(this, JJTPACKAGESPECIFICATION);
853 boolean jjtc000 = true;
854 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
855 try {
856 switch (jj_nt.kind) {
857 case CREATE:
858 jj_consume_token(CREATE);
859 switch (jj_nt.kind) {
860 case OR:
861 jj_consume_token(OR);
862 jj_consume_token(REPLACE);
863 break;
864 default:
865 jj_la1[10] = jj_gen;
866 ;
867 }
868 switch (jj_nt.kind) {
869 case EDITIONABLE:
870 case NONEDITIONABLE:
871 switch (jj_nt.kind) {
872 case EDITIONABLE:
873 jj_consume_token(EDITIONABLE);
874 break;
875 case NONEDITIONABLE:
876 jj_consume_token(NONEDITIONABLE);
877 break;
878 default:
879 jj_la1[11] = jj_gen;
880 jj_consume_token(-1);
881 throw new ParseException();
882 }
883 break;
884 default:
885 jj_la1[12] = jj_gen;
886 ;
887 }
888 break;
889 default:
890 jj_la1[13] = jj_gen;
891 ;
892 }
893 jj_consume_token(PACKAGE);
894 simpleNode = ObjectNameDeclaration();
895 label_5:
896 while (true) {
897 switch (jj_nt.kind) {
898 case AUTHID:
899 case ACCESSIBLE:
900 ;
901 break;
902 default:
903 jj_la1[14] = jj_gen;
904 break label_5;
905 }
906 switch (jj_nt.kind) {
907 case AUTHID:
908 jj_consume_token(AUTHID);
909 switch (jj_nt.kind) {
910 case CURRENT_USER:
911 jj_consume_token(CURRENT_USER);
912 break;
913 case DEFINER:
914 jj_consume_token(DEFINER);
915 break;
916 default:
917 jj_la1[15] = jj_gen;
918 jj_consume_token(-1);
919 throw new ParseException();
920 }
921 break;
922 case ACCESSIBLE:
923 AccessibleByClause();
924 break;
925 default:
926 jj_la1[16] = jj_gen;
927 jj_consume_token(-1);
928 throw new ParseException();
929 }
930 }
931 switch (jj_nt.kind) {
932 case WRAPPED:
933 WrappedObject();
934 break;
935 case AS:
936 case IS:
937 switch (jj_nt.kind) {
938 case IS:
939 jj_consume_token(IS);
940 break;
941 case AS:
942 jj_consume_token(AS);
943 break;
944 default:
945 jj_la1[17] = jj_gen;
946 jj_consume_token(-1);
947 throw new ParseException();
948 }
949 DeclarativeSection();
950 jj_consume_token(END);
951 switch (jj_nt.kind) {
952 case REPLACE:
953 case DEFINER:
954 case CURRENT_USER:
955 case SERIALLY_REUSABLE:
956 case RESTRICT_REFERENCES:
957 case EXCEPTION_INIT:
958 case AUTONOMOUS_TRANSACTION:
959 case LANGUAGE:
960 case ADD:
961 case AGGREGATE:
962 case ALL:
963 case ALTER:
964 case AND:
965 case ANY:
966 case ARRAY:
967 case AS:
968 case ASC:
969 case AT:
970 case ATTRIBUTE:
971 case AUTHID:
972 case AVG:
973 case BETWEEN:
974 case BINARY_INTEGER:
975 case BODY:
976 case BOOLEAN:
977 case BULK:
978 case BY:
979 case BYTE:
980 case CASCADE:
981 case CASE:
982 case CHAR:
983 case CHAR_BASE:
984 case CHECK:
985 case CLOSE:
986 case CLUSTER:
987 case COALESCE:
988 case COLLECT:
989 case COLUMN:
990 case COMMENT:
991 case COMMIT:
992 case COMPRESS:
993 case CONNECT:
994 case CONSTANT:
995 case CONSTRUCTOR:
996 case CONTINUE:
997 case CONVERT:
998 case CREATE:
999 case CURRENT:
1000 case CURRVAL:
1001 case CURSOR:
1002 case DATA:
1003 case DATE:
1004 case DAY:
1005 case DECLARE:
1006 case DECIMAL:
1007 case _DEFAULT:
1008 case DELETE:
1009 case DESC:
1010 case DISABLE:
1011 case DISTINCT:
1012 case DO:
1013 case DROP:
1014 case EDITIONABLE:
1015 case ELEMENT:
1016 case ELSE:
1017 case ELSIF:
1018 case ENABLE:
1019 case ESCAPE:
1020 case EXCEPT:
1021 case EXCEPTION:
1022 case EXCEPTIONS:
1023 case EXCLUSIVE:
1024 case EXECUTE:
1025 case EXISTS:
1026 case EXIT:
1027 case EXTERNAL:
1028 case EXTENDS:
1029 case EXTRACT:
1030 case FALSE:
1031 case FETCH:
1032 case FINAL:
1033 case FLOAT:
1034 case FOR:
1035 case FORALL:
1036 case FORCE:
1037 case FROM:
1038 case FUNCTION:
1039 case GLOBAL:
1040 case GOTO:
1041 case GROUP:
1042 case HASH:
1043 case HAVING:
1044 case HEAP:
1045 case HOUR:
1046 case IF:
1047 case IMMEDIATE:
1048 case IN:
1049 case INDEX:
1050 case INDICES:
1051 case INDEXTYPE:
1052 case INDICATOR:
1053 case INSERT:
1054 case INSTANTIABLE:
1055 case INTEGER:
1056 case INTERFACE:
1057 case INTERSECT:
1058 case INTERVAL:
1059 case INTO:
1060 case INVALIDATE:
1061 case IS:
1062 case ISOLATION:
1063 case JAVA:
1064 case LEVEL:
1065 case LIKE:
1066 case LIMIT:
1067 case LIMITED:
1068 case LOCK:
1069 case LONG:
1070 case LOOP:
1071 case MAP:
1072 case MAX:
1073 case MEMBER:
1074 case MERGE:
1075 case MIN:
1076 case MINUS:
1077 case MINUTE:
1078 case MLSLABEL:
1079 case MODIFY:
1080 case MOD:
1081 case MODE:
1082 case MONTH:
1083 case NATURAL:
1084 case NATURALN:
1085 case NEW:
1086 case NEXTVAL:
1087 case NO:
1088 case NOCOPY:
1089 case NONEDITIONABLE:
1090 case NOT:
1091 case NOWAIT:
1092 case NULL:
1093 case NULLIF:
1094 case NUMBER:
1095 case BFILE_BASE:
1096 case BLOB_BASE:
1097 case CLOB_BASE:
1098 case DATE_BASE:
1099 case NUMBER_BASE:
1100 case OBJECT:
1101 case OCIROWID:
1102 case OF:
1103 case OID:
1104 case ON:
1105 case OPAQUE:
1106 case OPEN:
1107 case OPERATOR:
1108 case OPTION:
1109 case OR:
1110 case ORDER:
1111 case ORGANIZATION:
1112 case OTHERS:
1113 case OUT:
1114 case OVERRIDING:
1115 case PACKAGE:
1116 case PARTITION:
1117 case PCTFREE:
1118 case PLS_INTEGER:
1119 case POSITIVE:
1120 case POSITIVEN:
1121 case PRESERVE:
1122 case PRIOR:
1123 case PROMPT:
1124 case PRIVATE:
1125 case PROCEDURE:
1126 case PUBLIC:
1127 case RAISE:
1128 case RANGE:
1129 case RAW:
1130 case REAL:
1131 case RECORD:
1132 case REF:
1133 case RELEASE:
1134 case RELIES_ON:
1135 case RENAME:
1136 case RESULT:
1137 case RETURN:
1138 case RETURNING:
1139 case REVERSE:
1140 case ROLLBACK:
1141 case ROW:
1142 case ROWS:
1143 case ROWID:
1144 case ROWNUM:
1145 case ROWTYPE:
1146 case SAVE:
1147 case SAVEPOINT:
1148 case SECOND:
1149 case SELECT:
1150 case SELF:
1151 case SEPARATE:
1152 case SET:
1153 case SHARE:
1154 case SMALLINT:
1155 case SPACE:
1156 case SQL:
1157 case SQLCODE:
1158 case SQLERRM:
1159 case START:
1160 case STATIC:
1161 case STDDEV:
1162 case SUBTYPE:
1163 case SUBSTITUTABLE:
1164 case SUCCESSFUL:
1165 case SUM:
1166 case SYNONYM:
1167 case SYSDATE:
1168 case SYS_REFCURSOR:
1169 case TABLE:
1170 case TEMPORARY:
1171 case THEN:
1172 case TIME:
1173 case TIMESTAMP:
1174 case TIMEZONE_REGION:
1175 case TIMEZONE_ABBR:
1176 case TIMEZONE_MINUTE:
1177 case TIMEZONE_HOUR:
1178 case TO:
1179 case TRANSACTION:
1180 case TRIGGER:
1181 case TRUE:
1182 case TYPE:
1183 case UI:
1184 case UNDER:
1185 case USING:
1186 case WHILE:
1187 case YES:
1188 case SHOW:
1189 case A:
1190 case UPDATE:
1191 case VARCHAR:
1192 case VARCHAR2:
1193 case DOUBLE:
1194 case DEC:
1195 case PRECISION:
1196 case INT:
1197 case NUMERIC:
1198 case SIGNTYPE:
1199 case NCHAR:
1200 case NVARCHAR2:
1201 case STRING:
1202 case UROWID:
1203 case VARRAY:
1204 case VARYING:
1205 case BFILE:
1206 case BLOB:
1207 case CLOB:
1208 case NCLOB:
1209 case YEAR:
1210 case LOCAL:
1211 case WITH:
1212 case ZONE:
1213 case CHARACTER:
1214 case AFTER:
1215 case BEFORE:
1216 case OLD:
1217 case PARENT:
1218 case ANALYZE:
1219 case ASSOCIATE:
1220 case AUDIT:
1221 case COMPOUND:
1222 case DATABASE:
1223 case CALL:
1224 case DDL:
1225 case DISASSOCIATE:
1226 case EACH:
1227 case FOLLOWS:
1228 case LOGOFF:
1229 case LOGON:
1230 case NESTED:
1231 case NOAUDIT:
1232 case SCHEMA:
1233 case SERVERERROR:
1234 case SHUTDOWN:
1235 case STARTUP:
1236 case STATEMENT:
1237 case STATISTICS:
1238 case SUSPEND:
1239 case TRUNCATE:
1240 case WRAPPED:
1241 case LIBRARY:
1242 case NAME:
1243 case STRUCT:
1244 case CONTEXT:
1245 case PARAMETERS:
1246 case LENGTH:
1247 case TDO:
1248 case MAXLEN:
1249 case CHARSETID:
1250 case CHARSETFORM:
1251 case ACCEPT:
1252 case ACCESSIBLE:
1253 case COPY:
1254 case DEFINE:
1255 case DISCONNECT:
1256 case HOST:
1257 case PRINT:
1258 case QUIT:
1259 case REMARK:
1260 case UNDEFINE:
1261 case VARIABLE:
1262 case WHENEVER:
1263 case ATTACH:
1264 case CAST:
1265 case TREAT:
1266 case TRIM:
1267 case LEFT:
1268 case RIGHT:
1269 case BOTH:
1270 case EMPTY:
1271 case MULTISET:
1272 case SUBMULTISET:
1273 case LEADING:
1274 case TRAILING:
1275 case CHAR_CS:
1276 case NCHAR_CS:
1277 case DBTIMEZONE:
1278 case SESSIONTIMEZONE:
1279 case AUTHENTICATED:
1280 case LINK:
1281 case SHARED:
1282 case DIRECTORY:
1283 case USER:
1284 case IDENTIFIER:
1285 case QUOTED_LITERAL:
1286 case SQLDATA_CLASS:
1287 case CUSTOMDATUM_CLASS:
1288 case ORADATA_CLASS:
1289 case JAVA_INTERFACE_CLASS:
1290 ID();
1291 break;
1292 default:
1293 jj_la1[18] = jj_gen;
1294 ;
1295 }
1296 jj_consume_token(4);
1297 break;
1298 default:
1299 jj_la1[19] = jj_gen;
1300 jj_consume_token(-1);
1301 throw new ParseException();
1302 }
1303 jjtree.closeNodeScope(jjtn000, true);
1304 jjtc000 = false;
1305 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
1306 } catch (Throwable jjte000) {
1307 if (jjtc000) {
1308 jjtree.clearNodeScope(jjtn000);
1309 jjtc000 = false;
1310 } else {
1311 jjtree.popNode();
1312 }
1313 if (jjte000 instanceof RuntimeException) {
1314 {if (true) throw (RuntimeException)jjte000;}
1315 }
1316 if (jjte000 instanceof ParseException) {
1317 {if (true) throw (ParseException)jjte000;}
1318 }
1319 {if (true) throw (Error)jjte000;}
1320 } finally {
1321 if (jjtc000) {
1322 jjtree.closeNodeScope(jjtn000, true);
1323 }
1324 }
1325 throw new Error("Missing return statement in function");
1326 }
1327
1328 final public ASTPackageBody PackageBody() throws ParseException {
1329
1330 ASTPackageBody jjtn000 = new ASTPackageBody(this, JJTPACKAGEBODY);
1331 boolean jjtc000 = true;
1332 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
1333 try {
1334 switch (jj_nt.kind) {
1335 case CREATE:
1336 jj_consume_token(CREATE);
1337 switch (jj_nt.kind) {
1338 case OR:
1339 jj_consume_token(OR);
1340 jj_consume_token(REPLACE);
1341 break;
1342 default:
1343 jj_la1[20] = jj_gen;
1344 ;
1345 }
1346 switch (jj_nt.kind) {
1347 case EDITIONABLE:
1348 case NONEDITIONABLE:
1349 switch (jj_nt.kind) {
1350 case EDITIONABLE:
1351 jj_consume_token(EDITIONABLE);
1352 break;
1353 case NONEDITIONABLE:
1354 jj_consume_token(NONEDITIONABLE);
1355 break;
1356 default:
1357 jj_la1[21] = jj_gen;
1358 jj_consume_token(-1);
1359 throw new ParseException();
1360 }
1361 break;
1362 default:
1363 jj_la1[22] = jj_gen;
1364 ;
1365 }
1366 break;
1367 default:
1368 jj_la1[23] = jj_gen;
1369 ;
1370 }
1371 switch (jj_nt.kind) {
1372 case PACKAGE:
1373 jj_consume_token(PACKAGE);
1374 break;
1375 case TYPE:
1376 jj_consume_token(TYPE);
1377 break;
1378 default:
1379 jj_la1[24] = jj_gen;
1380 jj_consume_token(-1);
1381 throw new ParseException();
1382 }
1383 jj_consume_token(BODY);
1384 simpleNode = ObjectNameDeclaration();
1385 switch (jj_nt.kind) {
1386 case WRAPPED:
1387 WrappedObject();
1388 break;
1389 case AS:
1390 case IS:
1391 switch (jj_nt.kind) {
1392 case IS:
1393 jj_consume_token(IS);
1394 break;
1395 case AS:
1396 jj_consume_token(AS);
1397 break;
1398 default:
1399 jj_la1[25] = jj_gen;
1400 jj_consume_token(-1);
1401 throw new ParseException();
1402 }
1403 DeclarativeSection();
1404 switch (jj_nt.kind) {
1405 case BEGIN:
1406 jj_consume_token(BEGIN);
1407 label_6:
1408 while (true) {
1409 switch (jj_nt.kind) {
1410 case 5:
1411 case 16:
1412 case 17:
1413 case 21:
1414 case REPLACE:
1415 case DEFINER:
1416 case CURRENT_USER:
1417 case LANGUAGE:
1418 case ADD:
1419 case AGGREGATE:
1420 case ARRAY:
1421 case AT:
1422 case ATTRIBUTE:
1423 case AUTHID:
1424 case BEGIN:
1425 case BODY:
1426 case BULK:
1427 case BYTE:
1428 case CASCADE:
1429 case CASE:
1430 case CLOSE:
1431 case COALESCE:
1432 case COLLECT:
1433 case COLUMN:
1434 case COMMENT:
1435 case COMMIT:
1436 case CONSTRUCTOR:
1437 case CONTINUE:
1438 case CONVERT:
1439 case CURRENT:
1440 case CURSOR:
1441 case DATA:
1442 case DATE:
1443 case DAY:
1444 case DECLARE:
1445 case DELETE:
1446 case DISABLE:
1447 case EDITIONABLE:
1448 case ELEMENT:
1449 case ENABLE:
1450 case ESCAPE:
1451 case EXCEPT:
1452 case EXCEPTIONS:
1453 case EXECUTE:
1454 case EXIT:
1455 case EXTERNAL:
1456 case EXTENDS:
1457 case EXTRACT:
1458 case FALSE:
1459 case FETCH:
1460 case FINAL:
1461 case FOR:
1462 case FORALL:
1463 case FORCE:
1464 case FUNCTION:
1465 case GLOBAL:
1466 case GOTO:
1467 case HASH:
1468 case HEAP:
1469 case HOUR:
1470 case IF:
1471 case IMMEDIATE:
1472 case INDICES:
1473 case INDEXTYPE:
1474 case INDICATOR:
1475 case INSERT:
1476 case INSTANTIABLE:
1477 case INTERVAL:
1478 case INVALIDATE:
1479 case ISOLATION:
1480 case JAVA:
1481 case LEVEL:
1482 case LIMIT:
1483 case LOCK:
1484 case LOOP:
1485 case MAP:
1486 case MAX:
1487 case MEMBER:
1488 case MERGE:
1489 case MIN:
1490 case MINUTE:
1491 case MLSLABEL:
1492 case MODIFY:
1493 case MOD:
1494 case MONTH:
1495 case NATURAL:
1496 case NEW:
1497 case NEW_DOT:
1498 case NO:
1499 case NONEDITIONABLE:
1500 case NOT:
1501 case NULL:
1502 case NULLIF:
1503 case OBJECT:
1504 case OID:
1505 case OPAQUE:
1506 case OPEN:
1507 case OPERATOR:
1508 case ORGANIZATION:
1509 case OTHERS:
1510 case OVERRIDING:
1511 case PACKAGE:
1512 case PARTITION:
1513 case PIPE:
1514 case PRESERVE:
1515 case PRIVATE:
1516 case PROCEDURE:
1517 case RAISE:
1518 case RANGE:
1519 case RAW:
1520 case REAL:
1521 case RECORD:
1522 case REF:
1523 case RELEASE:
1524 case RELIES_ON:
1525 case RENAME:
1526 case RESULT:
1527 case RETURN:
1528 case RETURNING:
1529 case REVERSE:
1530 case ROLLBACK:
1531 case ROW:
1532 case ROWS:
1533 case ROWID:
1534 case ROWNUM:
1535 case SAVE:
1536 case SAVEPOINT:
1537 case SECOND:
1538 case SELECT:
1539 case SELF:
1540 case SET:
1541 case SPACE:
1542 case SQL:
1543 case SQLCODE:
1544 case SQLERRM:
1545 case STATIC:
1546 case SUBTYPE:
1547 case SUBSTITUTABLE:
1548 case SUCCESSFUL:
1549 case SYSDATE:
1550 case SYS_REFCURSOR:
1551 case TEMPORARY:
1552 case TIME:
1553 case TIMESTAMP:
1554 case TIMEZONE_REGION:
1555 case TIMEZONE_ABBR:
1556 case TIMEZONE_MINUTE:
1557 case TIMEZONE_HOUR:
1558 case TRANSACTION:
1559 case TRUE:
1560 case TYPE:
1561 case UNDER:
1562 case USING:
1563 case WHILE:
1564 case YES:
1565 case SHOW:
1566 case A:
1567 case UPDATE:
1568 case DOUBLE:
1569 case DEC:
1570 case PRECISION:
1571 case INT:
1572 case NUMERIC:
1573 case NCHAR:
1574 case NVARCHAR2:
1575 case STRING:
1576 case UROWID:
1577 case VARRAY:
1578 case VARYING:
1579 case BFILE:
1580 case BLOB:
1581 case CLOB:
1582 case NCLOB:
1583 case YEAR:
1584 case LOCAL:
1585 case WITH:
1586 case ZONE:
1587 case CHARACTER:
1588 case AFTER:
1589 case BEFORE:
1590 case OLD:
1591 case PARENT:
1592 case CC_IF:
1593 case CC_ERROR:
1594 case ANALYZE:
1595 case ASSOCIATE:
1596 case AUDIT:
1597 case COMPOUND:
1598 case DATABASE:
1599 case CALL:
1600 case DDL:
1601 case DISASSOCIATE:
1602 case EACH:
1603 case FOLLOWS:
1604 case LOGOFF:
1605 case LOGON:
1606 case NESTED:
1607 case NOAUDIT:
1608 case SCHEMA:
1609 case SERVERERROR:
1610 case SHUTDOWN:
1611 case STARTUP:
1612 case STATEMENT:
1613 case STATISTICS:
1614 case SUSPEND:
1615 case TRUNCATE:
1616 case WRAPPED:
1617 case LIBRARY:
1618 case NAME:
1619 case STRUCT:
1620 case CONTEXT:
1621 case PARAMETERS:
1622 case LENGTH:
1623 case TDO:
1624 case MAXLEN:
1625 case CHARSETID:
1626 case CHARSETFORM:
1627 case ACCEPT:
1628 case ACCESSIBLE:
1629 case COPY:
1630 case DEFINE:
1631 case DISCONNECT:
1632 case HOST:
1633 case PRINT:
1634 case QUIT:
1635 case REMARK:
1636 case UNDEFINE:
1637 case VARIABLE:
1638 case WHENEVER:
1639 case ATTACH:
1640 case CAST:
1641 case TREAT:
1642 case TRIM:
1643 case LEFT:
1644 case RIGHT:
1645 case BOTH:
1646 case EMPTY:
1647 case MULTISET:
1648 case SUBMULTISET:
1649 case LEADING:
1650 case TRAILING:
1651 case CHAR_CS:
1652 case NCHAR_CS:
1653 case DBTIMEZONE:
1654 case SESSIONTIMEZONE:
1655 case AUTHENTICATED:
1656 case LINK:
1657 case SHARED:
1658 case DIRECTORY:
1659 case USER:
1660 case IDENTIFIER:
1661 case UNSIGNED_NUMERIC_LITERAL:
1662 case CHARACTER_LITERAL:
1663 case STRING_LITERAL:
1664 case QUOTED_LITERAL:
1665 ;
1666 break;
1667 default:
1668 jj_la1[26] = jj_gen;
1669 break label_6;
1670 }
1671 Statement();
1672 }
1673 switch (jj_nt.kind) {
1674 case EXCEPTION:
1675 ExceptionHandler();
1676 break;
1677 default:
1678 jj_la1[27] = jj_gen;
1679 ;
1680 }
1681 break;
1682 default:
1683 jj_la1[28] = jj_gen;
1684 ;
1685 }
1686 jj_consume_token(END);
1687 switch (jj_nt.kind) {
1688 case REPLACE:
1689 case DEFINER:
1690 case CURRENT_USER:
1691 case SERIALLY_REUSABLE:
1692 case RESTRICT_REFERENCES:
1693 case EXCEPTION_INIT:
1694 case AUTONOMOUS_TRANSACTION:
1695 case LANGUAGE:
1696 case ADD:
1697 case AGGREGATE:
1698 case ALL:
1699 case ALTER:
1700 case AND:
1701 case ANY:
1702 case ARRAY:
1703 case AS:
1704 case ASC:
1705 case AT:
1706 case ATTRIBUTE:
1707 case AUTHID:
1708 case AVG:
1709 case BETWEEN:
1710 case BINARY_INTEGER:
1711 case BODY:
1712 case BOOLEAN:
1713 case BULK:
1714 case BY:
1715 case BYTE:
1716 case CASCADE:
1717 case CASE:
1718 case CHAR:
1719 case CHAR_BASE:
1720 case CHECK:
1721 case CLOSE:
1722 case CLUSTER:
1723 case COALESCE:
1724 case COLLECT:
1725 case COLUMN:
1726 case COMMENT:
1727 case COMMIT:
1728 case COMPRESS:
1729 case CONNECT:
1730 case CONSTANT:
1731 case CONSTRUCTOR:
1732 case CONTINUE:
1733 case CONVERT:
1734 case CREATE:
1735 case CURRENT:
1736 case CURRVAL:
1737 case CURSOR:
1738 case DATA:
1739 case DATE:
1740 case DAY:
1741 case DECLARE:
1742 case DECIMAL:
1743 case _DEFAULT:
1744 case DELETE:
1745 case DESC:
1746 case DISABLE:
1747 case DISTINCT:
1748 case DO:
1749 case DROP:
1750 case EDITIONABLE:
1751 case ELEMENT:
1752 case ELSE:
1753 case ELSIF:
1754 case ENABLE:
1755 case ESCAPE:
1756 case EXCEPT:
1757 case EXCEPTION:
1758 case EXCEPTIONS:
1759 case EXCLUSIVE:
1760 case EXECUTE:
1761 case EXISTS:
1762 case EXIT:
1763 case EXTERNAL:
1764 case EXTENDS:
1765 case EXTRACT:
1766 case FALSE:
1767 case FETCH:
1768 case FINAL:
1769 case FLOAT:
1770 case FOR:
1771 case FORALL:
1772 case FORCE:
1773 case FROM:
1774 case FUNCTION:
1775 case GLOBAL:
1776 case GOTO:
1777 case GROUP:
1778 case HASH:
1779 case HAVING:
1780 case HEAP:
1781 case HOUR:
1782 case IF:
1783 case IMMEDIATE:
1784 case IN:
1785 case INDEX:
1786 case INDICES:
1787 case INDEXTYPE:
1788 case INDICATOR:
1789 case INSERT:
1790 case INSTANTIABLE:
1791 case INTEGER:
1792 case INTERFACE:
1793 case INTERSECT:
1794 case INTERVAL:
1795 case INTO:
1796 case INVALIDATE:
1797 case IS:
1798 case ISOLATION:
1799 case JAVA:
1800 case LEVEL:
1801 case LIKE:
1802 case LIMIT:
1803 case LIMITED:
1804 case LOCK:
1805 case LONG:
1806 case LOOP:
1807 case MAP:
1808 case MAX:
1809 case MEMBER:
1810 case MERGE:
1811 case MIN:
1812 case MINUS:
1813 case MINUTE:
1814 case MLSLABEL:
1815 case MODIFY:
1816 case MOD:
1817 case MODE:
1818 case MONTH:
1819 case NATURAL:
1820 case NATURALN:
1821 case NEW:
1822 case NEXTVAL:
1823 case NO:
1824 case NOCOPY:
1825 case NONEDITIONABLE:
1826 case NOT:
1827 case NOWAIT:
1828 case NULL:
1829 case NULLIF:
1830 case NUMBER:
1831 case BFILE_BASE:
1832 case BLOB_BASE:
1833 case CLOB_BASE:
1834 case DATE_BASE:
1835 case NUMBER_BASE:
1836 case OBJECT:
1837 case OCIROWID:
1838 case OF:
1839 case OID:
1840 case ON:
1841 case OPAQUE:
1842 case OPEN:
1843 case OPERATOR:
1844 case OPTION:
1845 case OR:
1846 case ORDER:
1847 case ORGANIZATION:
1848 case OTHERS:
1849 case OUT:
1850 case OVERRIDING:
1851 case PACKAGE:
1852 case PARTITION:
1853 case PCTFREE:
1854 case PLS_INTEGER:
1855 case POSITIVE:
1856 case POSITIVEN:
1857 case PRESERVE:
1858 case PRIOR:
1859 case PROMPT:
1860 case PRIVATE:
1861 case PROCEDURE:
1862 case PUBLIC:
1863 case RAISE:
1864 case RANGE:
1865 case RAW:
1866 case REAL:
1867 case RECORD:
1868 case REF:
1869 case RELEASE:
1870 case RELIES_ON:
1871 case RENAME:
1872 case RESULT:
1873 case RETURN:
1874 case RETURNING:
1875 case REVERSE:
1876 case ROLLBACK:
1877 case ROW:
1878 case ROWS:
1879 case ROWID:
1880 case ROWNUM:
1881 case ROWTYPE:
1882 case SAVE:
1883 case SAVEPOINT:
1884 case SECOND:
1885 case SELECT:
1886 case SELF:
1887 case SEPARATE:
1888 case SET:
1889 case SHARE:
1890 case SMALLINT:
1891 case SPACE:
1892 case SQL:
1893 case SQLCODE:
1894 case SQLERRM:
1895 case START:
1896 case STATIC:
1897 case STDDEV:
1898 case SUBTYPE:
1899 case SUBSTITUTABLE:
1900 case SUCCESSFUL:
1901 case SUM:
1902 case SYNONYM:
1903 case SYSDATE:
1904 case SYS_REFCURSOR:
1905 case TABLE:
1906 case TEMPORARY:
1907 case THEN:
1908 case TIME:
1909 case TIMESTAMP:
1910 case TIMEZONE_REGION:
1911 case TIMEZONE_ABBR:
1912 case TIMEZONE_MINUTE:
1913 case TIMEZONE_HOUR:
1914 case TO:
1915 case TRANSACTION:
1916 case TRIGGER:
1917 case TRUE:
1918 case TYPE:
1919 case UI:
1920 case UNDER:
1921 case USING:
1922 case WHILE:
1923 case YES:
1924 case SHOW:
1925 case A:
1926 case UPDATE:
1927 case VARCHAR:
1928 case VARCHAR2:
1929 case DOUBLE:
1930 case DEC:
1931 case PRECISION:
1932 case INT:
1933 case NUMERIC:
1934 case SIGNTYPE:
1935 case NCHAR:
1936 case NVARCHAR2:
1937 case STRING:
1938 case UROWID:
1939 case VARRAY:
1940 case VARYING:
1941 case BFILE:
1942 case BLOB:
1943 case CLOB:
1944 case NCLOB:
1945 case YEAR:
1946 case LOCAL:
1947 case WITH:
1948 case ZONE:
1949 case CHARACTER:
1950 case AFTER:
1951 case BEFORE:
1952 case OLD:
1953 case PARENT:
1954 case ANALYZE:
1955 case ASSOCIATE:
1956 case AUDIT:
1957 case COMPOUND:
1958 case DATABASE:
1959 case CALL:
1960 case DDL:
1961 case DISASSOCIATE:
1962 case EACH:
1963 case FOLLOWS:
1964 case LOGOFF:
1965 case LOGON:
1966 case NESTED:
1967 case NOAUDIT:
1968 case SCHEMA:
1969 case SERVERERROR:
1970 case SHUTDOWN:
1971 case STARTUP:
1972 case STATEMENT:
1973 case STATISTICS:
1974 case SUSPEND:
1975 case TRUNCATE:
1976 case WRAPPED:
1977 case LIBRARY:
1978 case NAME:
1979 case STRUCT:
1980 case CONTEXT:
1981 case PARAMETERS:
1982 case LENGTH:
1983 case TDO:
1984 case MAXLEN:
1985 case CHARSETID:
1986 case CHARSETFORM:
1987 case ACCEPT:
1988 case ACCESSIBLE:
1989 case COPY:
1990 case DEFINE:
1991 case DISCONNECT:
1992 case HOST:
1993 case PRINT:
1994 case QUIT:
1995 case REMARK:
1996 case UNDEFINE:
1997 case VARIABLE:
1998 case WHENEVER:
1999 case ATTACH:
2000 case CAST:
2001 case TREAT:
2002 case TRIM:
2003 case LEFT:
2004 case RIGHT:
2005 case BOTH:
2006 case EMPTY:
2007 case MULTISET:
2008 case SUBMULTISET:
2009 case LEADING:
2010 case TRAILING:
2011 case CHAR_CS:
2012 case NCHAR_CS:
2013 case DBTIMEZONE:
2014 case SESSIONTIMEZONE:
2015 case AUTHENTICATED:
2016 case LINK:
2017 case SHARED:
2018 case DIRECTORY:
2019 case USER:
2020 case IDENTIFIER:
2021 case QUOTED_LITERAL:
2022 case SQLDATA_CLASS:
2023 case CUSTOMDATUM_CLASS:
2024 case ORADATA_CLASS:
2025 case JAVA_INTERFACE_CLASS:
2026 ID();
2027 break;
2028 default:
2029 jj_la1[29] = jj_gen;
2030 ;
2031 }
2032 jj_consume_token(4);
2033 break;
2034 default:
2035 jj_la1[30] = jj_gen;
2036 jj_consume_token(-1);
2037 throw new ParseException();
2038 }
2039 jjtree.closeNodeScope(jjtn000, true);
2040 jjtc000 = false;
2041 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
2042 } catch (Throwable jjte000) {
2043 if (jjtc000) {
2044 jjtree.clearNodeScope(jjtn000);
2045 jjtc000 = false;
2046 } else {
2047 jjtree.popNode();
2048 }
2049 if (jjte000 instanceof RuntimeException) {
2050 {if (true) throw (RuntimeException)jjte000;}
2051 }
2052 if (jjte000 instanceof ParseException) {
2053 {if (true) throw (ParseException)jjte000;}
2054 }
2055 {if (true) throw (Error)jjte000;}
2056 } finally {
2057 if (jjtc000) {
2058 jjtree.closeNodeScope(jjtn000, true);
2059 }
2060 }
2061 throw new Error("Missing return statement in function");
2062 }
2063
2064 final public ASTDeclarativeUnit DeclarativeUnit() throws ParseException {
2065
2066 ASTDeclarativeUnit jjtn000 = new ASTDeclarativeUnit(this, JJTDECLARATIVEUNIT);
2067 boolean jjtc000 = true;
2068 jjtree.openNodeScope(jjtn000);
2069 try {
2070 switch (jj_nt.kind) {
2071 case PRAGMA:
2072 Pragma();
2073 break;
2074 default:
2075 jj_la1[31] = jj_gen;
2076 if (jj_2_16(2)) {
2077 ExceptionDeclaration();
2078 } else if (jj_2_17(2147483647)) {
2079 SubTypeDefinition();
2080 } else if (jj_2_18(2147483647)) {
2081 ProgramUnit();
2082 } else if (jj_2_19(4)) {
2083 VariableOrConstantDeclaration();
2084 } else if (jj_2_20(2)) {
2085 CursorSpecification();
2086 } else {
2087 switch (jj_nt.kind) {
2088 case CURSOR:
2089 CursorBody();
2090 break;
2091 case IDENTIFIER:
2092 CollectionDeclaration();
2093 break;
2094 case CONSTRUCTOR:
2095 case CREATE:
2096 case FINAL:
2097 case FUNCTION:
2098 case INSTANTIABLE:
2099 case MAP:
2100 case MEMBER:
2101 case NOT:
2102 case ORDER:
2103 case OVERRIDING:
2104 case PROCEDURE:
2105 case STATIC:
2106 MethodDeclaration();
2107 break;
2108 case CC_IF:
2109 CompilationDeclarationFragment();
2110 break;
2111 default:
2112 jj_la1[32] = jj_gen;
2113 jj_consume_token(-1);
2114 throw new ParseException();
2115 }
2116 }
2117 }
2118 jjtree.closeNodeScope(jjtn000, true);
2119 jjtc000 = false;
2120 {if (true) return jjtn000 ;}
2121 } catch (Throwable jjte000) {
2122 if (jjtc000) {
2123 jjtree.clearNodeScope(jjtn000);
2124 jjtc000 = false;
2125 } else {
2126 jjtree.popNode();
2127 }
2128 if (jjte000 instanceof RuntimeException) {
2129 {if (true) throw (RuntimeException)jjte000;}
2130 }
2131 if (jjte000 instanceof ParseException) {
2132 {if (true) throw (ParseException)jjte000;}
2133 }
2134 {if (true) throw (Error)jjte000;}
2135 } finally {
2136 if (jjtc000) {
2137 jjtree.closeNodeScope(jjtn000, true);
2138 }
2139 }
2140 throw new Error("Missing return statement in function");
2141 }
2142
2143 final public ASTDeclarativeSection DeclarativeSection() throws ParseException {
2144
2145 ASTDeclarativeSection jjtn000 = new ASTDeclarativeSection(this, JJTDECLARATIVESECTION);
2146 boolean jjtc000 = true;
2147 jjtree.openNodeScope(jjtn000);
2148 try {
2149 label_7:
2150 while (true) {
2151 switch (jj_nt.kind) {
2152 case REPLACE:
2153 case DEFINER:
2154 case CURRENT_USER:
2155 case SERIALLY_REUSABLE:
2156 case RESTRICT_REFERENCES:
2157 case EXCEPTION_INIT:
2158 case AUTONOMOUS_TRANSACTION:
2159 case LANGUAGE:
2160 case ADD:
2161 case AGGREGATE:
2162 case ALL:
2163 case ALTER:
2164 case AND:
2165 case ANY:
2166 case ARRAY:
2167 case AS:
2168 case ASC:
2169 case AT:
2170 case ATTRIBUTE:
2171 case AUTHID:
2172 case AVG:
2173 case BETWEEN:
2174 case BINARY_INTEGER:
2175 case BODY:
2176 case BOOLEAN:
2177 case BULK:
2178 case BY:
2179 case BYTE:
2180 case CASCADE:
2181 case CASE:
2182 case CHAR:
2183 case CHAR_BASE:
2184 case CHECK:
2185 case CLOSE:
2186 case CLUSTER:
2187 case COALESCE:
2188 case COLLECT:
2189 case COLUMN:
2190 case COMMENT:
2191 case COMMIT:
2192 case COMPRESS:
2193 case CONNECT:
2194 case CONSTANT:
2195 case CONSTRUCTOR:
2196 case CONTINUE:
2197 case CONVERT:
2198 case CREATE:
2199 case CURRENT:
2200 case CURRVAL:
2201 case CURSOR:
2202 case DATA:
2203 case DATE:
2204 case DAY:
2205 case DECLARE:
2206 case DECIMAL:
2207 case _DEFAULT:
2208 case DELETE:
2209 case DESC:
2210 case DISABLE:
2211 case DISTINCT:
2212 case DO:
2213 case DROP:
2214 case EDITIONABLE:
2215 case ELEMENT:
2216 case ELSE:
2217 case ELSIF:
2218 case ENABLE:
2219 case ESCAPE:
2220 case EXCEPT:
2221 case EXCEPTION:
2222 case EXCEPTIONS:
2223 case EXCLUSIVE:
2224 case EXECUTE:
2225 case EXISTS:
2226 case EXIT:
2227 case EXTERNAL:
2228 case EXTENDS:
2229 case EXTRACT:
2230 case FALSE:
2231 case FETCH:
2232 case FINAL:
2233 case FLOAT:
2234 case FOR:
2235 case FORALL:
2236 case FORCE:
2237 case FROM:
2238 case FUNCTION:
2239 case GLOBAL:
2240 case GOTO:
2241 case GROUP:
2242 case HASH:
2243 case HAVING:
2244 case HEAP:
2245 case HOUR:
2246 case IF:
2247 case IMMEDIATE:
2248 case IN:
2249 case INDEX:
2250 case INDICES:
2251 case INDEXTYPE:
2252 case INDICATOR:
2253 case INSERT:
2254 case INSTANTIABLE:
2255 case INTEGER:
2256 case INTERFACE:
2257 case INTERSECT:
2258 case INTERVAL:
2259 case INTO:
2260 case INVALIDATE:
2261 case IS:
2262 case ISOLATION:
2263 case JAVA:
2264 case LEVEL:
2265 case LIKE:
2266 case LIMIT:
2267 case LIMITED:
2268 case LOCK:
2269 case LONG:
2270 case LOOP:
2271 case MAP:
2272 case MAX:
2273 case MEMBER:
2274 case MERGE:
2275 case MIN:
2276 case MINUS:
2277 case MINUTE:
2278 case MLSLABEL:
2279 case MODIFY:
2280 case MOD:
2281 case MODE:
2282 case MONTH:
2283 case NATURAL:
2284 case NATURALN:
2285 case NEW:
2286 case NEXTVAL:
2287 case NO:
2288 case NOCOPY:
2289 case NONEDITIONABLE:
2290 case NOT:
2291 case NOWAIT:
2292 case NULL:
2293 case NULLIF:
2294 case NUMBER:
2295 case BFILE_BASE:
2296 case BLOB_BASE:
2297 case CLOB_BASE:
2298 case DATE_BASE:
2299 case NUMBER_BASE:
2300 case OBJECT:
2301 case OCIROWID:
2302 case OF:
2303 case OID:
2304 case ON:
2305 case OPAQUE:
2306 case OPEN:
2307 case OPERATOR:
2308 case OPTION:
2309 case OR:
2310 case ORDER:
2311 case ORGANIZATION:
2312 case OTHERS:
2313 case OUT:
2314 case OVERRIDING:
2315 case PACKAGE:
2316 case PARTITION:
2317 case PCTFREE:
2318 case PLS_INTEGER:
2319 case POSITIVE:
2320 case POSITIVEN:
2321 case PRAGMA:
2322 case PRESERVE:
2323 case PRIOR:
2324 case PROMPT:
2325 case PRIVATE:
2326 case PROCEDURE:
2327 case PUBLIC:
2328 case RAISE:
2329 case RANGE:
2330 case RAW:
2331 case REAL:
2332 case RECORD:
2333 case REF:
2334 case RELEASE:
2335 case RELIES_ON:
2336 case RENAME:
2337 case RESULT:
2338 case RETURN:
2339 case RETURNING:
2340 case REVERSE:
2341 case ROLLBACK:
2342 case ROW:
2343 case ROWS:
2344 case ROWID:
2345 case ROWNUM:
2346 case ROWTYPE:
2347 case SAVE:
2348 case SAVEPOINT:
2349 case SECOND:
2350 case SELECT:
2351 case SELF:
2352 case SEPARATE:
2353 case SET:
2354 case SHARE:
2355 case SMALLINT:
2356 case SPACE:
2357 case SQL:
2358 case SQLCODE:
2359 case SQLERRM:
2360 case START:
2361 case STATIC:
2362 case STDDEV:
2363 case SUBTYPE:
2364 case SUBSTITUTABLE:
2365 case SUCCESSFUL:
2366 case SUM:
2367 case SYNONYM:
2368 case SYSDATE:
2369 case SYS_REFCURSOR:
2370 case TABLE:
2371 case TEMPORARY:
2372 case THEN:
2373 case TIME:
2374 case TIMESTAMP:
2375 case TIMEZONE_REGION:
2376 case TIMEZONE_ABBR:
2377 case TIMEZONE_MINUTE:
2378 case TIMEZONE_HOUR:
2379 case TO:
2380 case TRANSACTION:
2381 case TRIGGER:
2382 case TRUE:
2383 case TYPE:
2384 case UI:
2385 case UNDER:
2386 case USING:
2387 case WHILE:
2388 case YES:
2389 case SHOW:
2390 case A:
2391 case UPDATE:
2392 case VARCHAR:
2393 case VARCHAR2:
2394 case DOUBLE:
2395 case DEC:
2396 case PRECISION:
2397 case INT:
2398 case NUMERIC:
2399 case SIGNTYPE:
2400 case NCHAR:
2401 case NVARCHAR2:
2402 case STRING:
2403 case UROWID:
2404 case VARRAY:
2405 case VARYING:
2406 case BFILE:
2407 case BLOB:
2408 case CLOB:
2409 case NCLOB:
2410 case YEAR:
2411 case LOCAL:
2412 case WITH:
2413 case ZONE:
2414 case CHARACTER:
2415 case AFTER:
2416 case BEFORE:
2417 case OLD:
2418 case PARENT:
2419 case CC_IF:
2420 case ANALYZE:
2421 case ASSOCIATE:
2422 case AUDIT:
2423 case COMPOUND:
2424 case DATABASE:
2425 case CALL:
2426 case DDL:
2427 case DISASSOCIATE:
2428 case EACH:
2429 case FOLLOWS:
2430 case LOGOFF:
2431 case LOGON:
2432 case NESTED:
2433 case NOAUDIT:
2434 case SCHEMA:
2435 case SERVERERROR:
2436 case SHUTDOWN:
2437 case STARTUP:
2438 case STATEMENT:
2439 case STATISTICS:
2440 case SUSPEND:
2441 case TRUNCATE:
2442 case WRAPPED:
2443 case LIBRARY:
2444 case NAME:
2445 case STRUCT:
2446 case CONTEXT:
2447 case PARAMETERS:
2448 case LENGTH:
2449 case TDO:
2450 case MAXLEN:
2451 case CHARSETID:
2452 case CHARSETFORM:
2453 case ACCEPT:
2454 case ACCESSIBLE:
2455 case COPY:
2456 case DEFINE:
2457 case DISCONNECT:
2458 case HOST:
2459 case PRINT:
2460 case QUIT:
2461 case REMARK:
2462 case UNDEFINE:
2463 case VARIABLE:
2464 case WHENEVER:
2465 case ATTACH:
2466 case CAST:
2467 case TREAT:
2468 case TRIM:
2469 case LEFT:
2470 case RIGHT:
2471 case BOTH:
2472 case EMPTY:
2473 case MULTISET:
2474 case SUBMULTISET:
2475 case LEADING:
2476 case TRAILING:
2477 case CHAR_CS:
2478 case NCHAR_CS:
2479 case DBTIMEZONE:
2480 case SESSIONTIMEZONE:
2481 case AUTHENTICATED:
2482 case LINK:
2483 case SHARED:
2484 case DIRECTORY:
2485 case USER:
2486 case IDENTIFIER:
2487 case QUOTED_LITERAL:
2488 case SQLDATA_CLASS:
2489 case CUSTOMDATUM_CLASS:
2490 case ORADATA_CLASS:
2491 case JAVA_INTERFACE_CLASS:
2492 ;
2493 break;
2494 default:
2495 jj_la1[33] = jj_gen;
2496 break label_7;
2497 }
2498 DeclarativeUnit();
2499 }
2500 jjtree.closeNodeScope(jjtn000, true);
2501 jjtc000 = false;
2502 {if (true) return jjtn000 ;}
2503 } catch (Throwable jjte000) {
2504 if (jjtc000) {
2505 jjtree.clearNodeScope(jjtn000);
2506 jjtc000 = false;
2507 } else {
2508 jjtree.popNode();
2509 }
2510 if (jjte000 instanceof RuntimeException) {
2511 {if (true) throw (RuntimeException)jjte000;}
2512 }
2513 if (jjte000 instanceof ParseException) {
2514 {if (true) throw (ParseException)jjte000;}
2515 }
2516 {if (true) throw (Error)jjte000;}
2517 } finally {
2518 if (jjtc000) {
2519 jjtree.closeNodeScope(jjtn000, true);
2520 }
2521 }
2522 throw new Error("Missing return statement in function");
2523 }
2524
2525 final public ASTCompilationDeclarationFragment CompilationDeclarationFragment() throws ParseException {
2526
2527 ASTCompilationDeclarationFragment jjtn000 = new ASTCompilationDeclarationFragment(this, JJTCOMPILATIONDECLARATIONFRAGMENT);
2528 boolean jjtc000 = true;
2529 jjtree.openNodeScope(jjtn000);
2530 try {
2531 jj_consume_token(CC_IF);
2532 ConditionalOrExpression();
2533 jj_consume_token(CC_THEN);
2534 label_8:
2535 while (true) {
2536 switch (jj_nt.kind) {
2537 case REPLACE:
2538 case DEFINER:
2539 case CURRENT_USER:
2540 case SERIALLY_REUSABLE:
2541 case RESTRICT_REFERENCES:
2542 case EXCEPTION_INIT:
2543 case AUTONOMOUS_TRANSACTION:
2544 case LANGUAGE:
2545 case ADD:
2546 case AGGREGATE:
2547 case ALL:
2548 case ALTER:
2549 case AND:
2550 case ANY:
2551 case ARRAY:
2552 case AS:
2553 case ASC:
2554 case AT:
2555 case ATTRIBUTE:
2556 case AUTHID:
2557 case AVG:
2558 case BETWEEN:
2559 case BINARY_INTEGER:
2560 case BODY:
2561 case BOOLEAN:
2562 case BULK:
2563 case BY:
2564 case BYTE:
2565 case CASCADE:
2566 case CASE:
2567 case CHAR:
2568 case CHAR_BASE:
2569 case CHECK:
2570 case CLOSE:
2571 case CLUSTER:
2572 case COALESCE:
2573 case COLLECT:
2574 case COLUMN:
2575 case COMMENT:
2576 case COMMIT:
2577 case COMPRESS:
2578 case CONNECT:
2579 case CONSTANT:
2580 case CONSTRUCTOR:
2581 case CONTINUE:
2582 case CONVERT:
2583 case CREATE:
2584 case CURRENT:
2585 case CURRVAL:
2586 case CURSOR:
2587 case DATA:
2588 case DATE:
2589 case DAY:
2590 case DECLARE:
2591 case DECIMAL:
2592 case _DEFAULT:
2593 case DELETE:
2594 case DESC:
2595 case DISABLE:
2596 case DISTINCT:
2597 case DO:
2598 case DROP:
2599 case EDITIONABLE:
2600 case ELEMENT:
2601 case ELSE:
2602 case ELSIF:
2603 case ENABLE:
2604 case ESCAPE:
2605 case EXCEPT:
2606 case EXCEPTION:
2607 case EXCEPTIONS:
2608 case EXCLUSIVE:
2609 case EXECUTE:
2610 case EXISTS:
2611 case EXIT:
2612 case EXTERNAL:
2613 case EXTENDS:
2614 case EXTRACT:
2615 case FALSE:
2616 case FETCH:
2617 case FINAL:
2618 case FLOAT:
2619 case FOR:
2620 case FORALL:
2621 case FORCE:
2622 case FROM:
2623 case FUNCTION:
2624 case GLOBAL:
2625 case GOTO:
2626 case GROUP:
2627 case HASH:
2628 case HAVING:
2629 case HEAP:
2630 case HOUR:
2631 case IF:
2632 case IMMEDIATE:
2633 case IN:
2634 case INDEX:
2635 case INDICES:
2636 case INDEXTYPE:
2637 case INDICATOR:
2638 case INSERT:
2639 case INSTANTIABLE:
2640 case INTEGER:
2641 case INTERFACE:
2642 case INTERSECT:
2643 case INTERVAL:
2644 case INTO:
2645 case INVALIDATE:
2646 case IS:
2647 case ISOLATION:
2648 case JAVA:
2649 case LEVEL:
2650 case LIKE:
2651 case LIMIT:
2652 case LIMITED:
2653 case LOCK:
2654 case LONG:
2655 case LOOP:
2656 case MAP:
2657 case MAX:
2658 case MEMBER:
2659 case MERGE:
2660 case MIN:
2661 case MINUS:
2662 case MINUTE:
2663 case MLSLABEL:
2664 case MODIFY:
2665 case MOD:
2666 case MODE:
2667 case MONTH:
2668 case NATURAL:
2669 case NATURALN:
2670 case NEW:
2671 case NEXTVAL:
2672 case NO:
2673 case NOCOPY:
2674 case NONEDITIONABLE:
2675 case NOT:
2676 case NOWAIT:
2677 case NULL:
2678 case NULLIF:
2679 case NUMBER:
2680 case BFILE_BASE:
2681 case BLOB_BASE:
2682 case CLOB_BASE:
2683 case DATE_BASE:
2684 case NUMBER_BASE:
2685 case OBJECT:
2686 case OCIROWID:
2687 case OF:
2688 case OID:
2689 case ON:
2690 case OPAQUE:
2691 case OPEN:
2692 case OPERATOR:
2693 case OPTION:
2694 case OR:
2695 case ORDER:
2696 case ORGANIZATION:
2697 case OTHERS:
2698 case OUT:
2699 case OVERRIDING:
2700 case PACKAGE:
2701 case PARTITION:
2702 case PCTFREE:
2703 case PLS_INTEGER:
2704 case POSITIVE:
2705 case POSITIVEN:
2706 case PRAGMA:
2707 case PRESERVE:
2708 case PRIOR:
2709 case PROMPT:
2710 case PRIVATE:
2711 case PROCEDURE:
2712 case PUBLIC:
2713 case RAISE:
2714 case RANGE:
2715 case RAW:
2716 case REAL:
2717 case RECORD:
2718 case REF:
2719 case RELEASE:
2720 case RELIES_ON:
2721 case RENAME:
2722 case RESULT:
2723 case RETURN:
2724 case RETURNING:
2725 case REVERSE:
2726 case ROLLBACK:
2727 case ROW:
2728 case ROWS:
2729 case ROWID:
2730 case ROWNUM:
2731 case ROWTYPE:
2732 case SAVE:
2733 case SAVEPOINT:
2734 case SECOND:
2735 case SELECT:
2736 case SELF:
2737 case SEPARATE:
2738 case SET:
2739 case SHARE:
2740 case SMALLINT:
2741 case SPACE:
2742 case SQL:
2743 case SQLCODE:
2744 case SQLERRM:
2745 case START:
2746 case STATIC:
2747 case STDDEV:
2748 case SUBTYPE:
2749 case SUBSTITUTABLE:
2750 case SUCCESSFUL:
2751 case SUM:
2752 case SYNONYM:
2753 case SYSDATE:
2754 case SYS_REFCURSOR:
2755 case TABLE:
2756 case TEMPORARY:
2757 case THEN:
2758 case TIME:
2759 case TIMESTAMP:
2760 case TIMEZONE_REGION:
2761 case TIMEZONE_ABBR:
2762 case TIMEZONE_MINUTE:
2763 case TIMEZONE_HOUR:
2764 case TO:
2765 case TRANSACTION:
2766 case TRIGGER:
2767 case TRUE:
2768 case TYPE:
2769 case UI:
2770 case UNDER:
2771 case USING:
2772 case WHILE:
2773 case YES:
2774 case SHOW:
2775 case A:
2776 case UPDATE:
2777 case VARCHAR:
2778 case VARCHAR2:
2779 case DOUBLE:
2780 case DEC:
2781 case PRECISION:
2782 case INT:
2783 case NUMERIC:
2784 case SIGNTYPE:
2785 case NCHAR:
2786 case NVARCHAR2:
2787 case STRING:
2788 case UROWID:
2789 case VARRAY:
2790 case VARYING:
2791 case BFILE:
2792 case BLOB:
2793 case CLOB:
2794 case NCLOB:
2795 case YEAR:
2796 case LOCAL:
2797 case WITH:
2798 case ZONE:
2799 case CHARACTER:
2800 case AFTER:
2801 case BEFORE:
2802 case OLD:
2803 case PARENT:
2804 case CC_IF:
2805 case CC_ERROR:
2806 case ANALYZE:
2807 case ASSOCIATE:
2808 case AUDIT:
2809 case COMPOUND:
2810 case DATABASE:
2811 case CALL:
2812 case DDL:
2813 case DISASSOCIATE:
2814 case EACH:
2815 case FOLLOWS:
2816 case LOGOFF:
2817 case LOGON:
2818 case NESTED:
2819 case NOAUDIT:
2820 case SCHEMA:
2821 case SERVERERROR:
2822 case SHUTDOWN:
2823 case STARTUP:
2824 case STATEMENT:
2825 case STATISTICS:
2826 case SUSPEND:
2827 case TRUNCATE:
2828 case WRAPPED:
2829 case LIBRARY:
2830 case NAME:
2831 case STRUCT:
2832 case CONTEXT:
2833 case PARAMETERS:
2834 case LENGTH:
2835 case TDO:
2836 case MAXLEN:
2837 case CHARSETID:
2838 case CHARSETFORM:
2839 case ACCEPT:
2840 case ACCESSIBLE:
2841 case COPY:
2842 case DEFINE:
2843 case DISCONNECT:
2844 case HOST:
2845 case PRINT:
2846 case QUIT:
2847 case REMARK:
2848 case UNDEFINE:
2849 case VARIABLE:
2850 case WHENEVER:
2851 case ATTACH:
2852 case CAST:
2853 case TREAT:
2854 case TRIM:
2855 case LEFT:
2856 case RIGHT:
2857 case BOTH:
2858 case EMPTY:
2859 case MULTISET:
2860 case SUBMULTISET:
2861 case LEADING:
2862 case TRAILING:
2863 case CHAR_CS:
2864 case NCHAR_CS:
2865 case DBTIMEZONE:
2866 case SESSIONTIMEZONE:
2867 case AUTHENTICATED:
2868 case LINK:
2869 case SHARED:
2870 case DIRECTORY:
2871 case USER:
2872 case IDENTIFIER:
2873 case QUOTED_LITERAL:
2874 case SQLDATA_CLASS:
2875 case CUSTOMDATUM_CLASS:
2876 case ORADATA_CLASS:
2877 case JAVA_INTERFACE_CLASS:
2878 ;
2879 break;
2880 default:
2881 jj_la1[34] = jj_gen;
2882 break label_8;
2883 }
2884 switch (jj_nt.kind) {
2885 case REPLACE:
2886 case DEFINER:
2887 case CURRENT_USER:
2888 case SERIALLY_REUSABLE:
2889 case RESTRICT_REFERENCES:
2890 case EXCEPTION_INIT:
2891 case AUTONOMOUS_TRANSACTION:
2892 case LANGUAGE:
2893 case ADD:
2894 case AGGREGATE:
2895 case ALL:
2896 case ALTER:
2897 case AND:
2898 case ANY:
2899 case ARRAY:
2900 case AS:
2901 case ASC:
2902 case AT:
2903 case ATTRIBUTE:
2904 case AUTHID:
2905 case AVG:
2906 case BETWEEN:
2907 case BINARY_INTEGER:
2908 case BODY:
2909 case BOOLEAN:
2910 case BULK:
2911 case BY:
2912 case BYTE:
2913 case CASCADE:
2914 case CASE:
2915 case CHAR:
2916 case CHAR_BASE:
2917 case CHECK:
2918 case CLOSE:
2919 case CLUSTER:
2920 case COALESCE:
2921 case COLLECT:
2922 case COLUMN:
2923 case COMMENT:
2924 case COMMIT:
2925 case COMPRESS:
2926 case CONNECT:
2927 case CONSTANT:
2928 case CONSTRUCTOR:
2929 case CONTINUE:
2930 case CONVERT:
2931 case CREATE:
2932 case CURRENT:
2933 case CURRVAL:
2934 case CURSOR:
2935 case DATA:
2936 case DATE:
2937 case DAY:
2938 case DECLARE:
2939 case DECIMAL:
2940 case _DEFAULT:
2941 case DELETE:
2942 case DESC:
2943 case DISABLE:
2944 case DISTINCT:
2945 case DO:
2946 case DROP:
2947 case EDITIONABLE:
2948 case ELEMENT:
2949 case ELSE:
2950 case ELSIF:
2951 case ENABLE:
2952 case ESCAPE:
2953 case EXCEPT:
2954 case EXCEPTION:
2955 case EXCEPTIONS:
2956 case EXCLUSIVE:
2957 case EXECUTE:
2958 case EXISTS:
2959 case EXIT:
2960 case EXTERNAL:
2961 case EXTENDS:
2962 case EXTRACT:
2963 case FALSE:
2964 case FETCH:
2965 case FINAL:
2966 case FLOAT:
2967 case FOR:
2968 case FORALL:
2969 case FORCE:
2970 case FROM:
2971 case FUNCTION:
2972 case GLOBAL:
2973 case GOTO:
2974 case GROUP:
2975 case HASH:
2976 case HAVING:
2977 case HEAP:
2978 case HOUR:
2979 case IF:
2980 case IMMEDIATE:
2981 case IN:
2982 case INDEX:
2983 case INDICES:
2984 case INDEXTYPE:
2985 case INDICATOR:
2986 case INSERT:
2987 case INSTANTIABLE:
2988 case INTEGER:
2989 case INTERFACE:
2990 case INTERSECT:
2991 case INTERVAL:
2992 case INTO:
2993 case INVALIDATE:
2994 case IS:
2995 case ISOLATION:
2996 case JAVA:
2997 case LEVEL:
2998 case LIKE:
2999 case LIMIT:
3000 case LIMITED:
3001 case LOCK:
3002 case LONG:
3003 case LOOP:
3004 case MAP:
3005 case MAX:
3006 case MEMBER:
3007 case MERGE:
3008 case MIN:
3009 case MINUS:
3010 case MINUTE:
3011 case MLSLABEL:
3012 case MODIFY:
3013 case MOD:
3014 case MODE:
3015 case MONTH:
3016 case NATURAL:
3017 case NATURALN:
3018 case NEW:
3019 case NEXTVAL:
3020 case NO:
3021 case NOCOPY:
3022 case NONEDITIONABLE:
3023 case NOT:
3024 case NOWAIT:
3025 case NULL:
3026 case NULLIF:
3027 case NUMBER:
3028 case BFILE_BASE:
3029 case BLOB_BASE:
3030 case CLOB_BASE:
3031 case DATE_BASE:
3032 case NUMBER_BASE:
3033 case OBJECT:
3034 case OCIROWID:
3035 case OF:
3036 case OID:
3037 case ON:
3038 case OPAQUE:
3039 case OPEN:
3040 case OPERATOR:
3041 case OPTION:
3042 case OR:
3043 case ORDER:
3044 case ORGANIZATION:
3045 case OTHERS:
3046 case OUT:
3047 case OVERRIDING:
3048 case PACKAGE:
3049 case PARTITION:
3050 case PCTFREE:
3051 case PLS_INTEGER:
3052 case POSITIVE:
3053 case POSITIVEN:
3054 case PRAGMA:
3055 case PRESERVE:
3056 case PRIOR:
3057 case PROMPT:
3058 case PRIVATE:
3059 case PROCEDURE:
3060 case PUBLIC:
3061 case RAISE:
3062 case RANGE:
3063 case RAW:
3064 case REAL:
3065 case RECORD:
3066 case REF:
3067 case RELEASE:
3068 case RELIES_ON:
3069 case RENAME:
3070 case RESULT:
3071 case RETURN:
3072 case RETURNING:
3073 case REVERSE:
3074 case ROLLBACK:
3075 case ROW:
3076 case ROWS:
3077 case ROWID:
3078 case ROWNUM:
3079 case ROWTYPE:
3080 case SAVE:
3081 case SAVEPOINT:
3082 case SECOND:
3083 case SELECT:
3084 case SELF:
3085 case SEPARATE:
3086 case SET:
3087 case SHARE:
3088 case SMALLINT:
3089 case SPACE:
3090 case SQL:
3091 case SQLCODE:
3092 case SQLERRM:
3093 case START:
3094 case STATIC:
3095 case STDDEV:
3096 case SUBTYPE:
3097 case SUBSTITUTABLE:
3098 case SUCCESSFUL:
3099 case SUM:
3100 case SYNONYM:
3101 case SYSDATE:
3102 case SYS_REFCURSOR:
3103 case TABLE:
3104 case TEMPORARY:
3105 case THEN:
3106 case TIME:
3107 case TIMESTAMP:
3108 case TIMEZONE_REGION:
3109 case TIMEZONE_ABBR:
3110 case TIMEZONE_MINUTE:
3111 case TIMEZONE_HOUR:
3112 case TO:
3113 case TRANSACTION:
3114 case TRIGGER:
3115 case TRUE:
3116 case TYPE:
3117 case UI:
3118 case UNDER:
3119 case USING:
3120 case WHILE:
3121 case YES:
3122 case SHOW:
3123 case A:
3124 case UPDATE:
3125 case VARCHAR:
3126 case VARCHAR2:
3127 case DOUBLE:
3128 case DEC:
3129 case PRECISION:
3130 case INT:
3131 case NUMERIC:
3132 case SIGNTYPE:
3133 case NCHAR:
3134 case NVARCHAR2:
3135 case STRING:
3136 case UROWID:
3137 case VARRAY:
3138 case VARYING:
3139 case BFILE:
3140 case BLOB:
3141 case CLOB:
3142 case NCLOB:
3143 case YEAR:
3144 case LOCAL:
3145 case WITH:
3146 case ZONE:
3147 case CHARACTER:
3148 case AFTER:
3149 case BEFORE:
3150 case OLD:
3151 case PARENT:
3152 case CC_IF:
3153 case ANALYZE:
3154 case ASSOCIATE:
3155 case AUDIT:
3156 case COMPOUND:
3157 case DATABASE:
3158 case CALL:
3159 case DDL:
3160 case DISASSOCIATE:
3161 case EACH:
3162 case FOLLOWS:
3163 case LOGOFF:
3164 case LOGON:
3165 case NESTED:
3166 case NOAUDIT:
3167 case SCHEMA:
3168 case SERVERERROR:
3169 case SHUTDOWN:
3170 case STARTUP:
3171 case STATEMENT:
3172 case STATISTICS:
3173 case SUSPEND:
3174 case TRUNCATE:
3175 case WRAPPED:
3176 case LIBRARY:
3177 case NAME:
3178 case STRUCT:
3179 case CONTEXT:
3180 case PARAMETERS:
3181 case LENGTH:
3182 case TDO:
3183 case MAXLEN:
3184 case CHARSETID:
3185 case CHARSETFORM:
3186 case ACCEPT:
3187 case ACCESSIBLE:
3188 case COPY:
3189 case DEFINE:
3190 case DISCONNECT:
3191 case HOST:
3192 case PRINT:
3193 case QUIT:
3194 case REMARK:
3195 case UNDEFINE:
3196 case VARIABLE:
3197 case WHENEVER:
3198 case ATTACH:
3199 case CAST:
3200 case TREAT:
3201 case TRIM:
3202 case LEFT:
3203 case RIGHT:
3204 case BOTH:
3205 case EMPTY:
3206 case MULTISET:
3207 case SUBMULTISET:
3208 case LEADING:
3209 case TRAILING:
3210 case CHAR_CS:
3211 case NCHAR_CS:
3212 case DBTIMEZONE:
3213 case SESSIONTIMEZONE:
3214 case AUTHENTICATED:
3215 case LINK:
3216 case SHARED:
3217 case DIRECTORY:
3218 case USER:
3219 case IDENTIFIER:
3220 case QUOTED_LITERAL:
3221 case SQLDATA_CLASS:
3222 case CUSTOMDATUM_CLASS:
3223 case ORADATA_CLASS:
3224 case JAVA_INTERFACE_CLASS:
3225 DeclarativeUnit();
3226 break;
3227 case CC_ERROR:
3228 jj_consume_token(CC_ERROR);
3229 Expression();
3230 jj_consume_token(CC_END);
3231 break;
3232 default:
3233 jj_la1[35] = jj_gen;
3234 jj_consume_token(-1);
3235 throw new ParseException();
3236 }
3237 }
3238 label_9:
3239 while (true) {
3240 switch (jj_nt.kind) {
3241 case CC_ELSIF:
3242 ;
3243 break;
3244 default:
3245 jj_la1[36] = jj_gen;
3246 break label_9;
3247 }
3248 jj_consume_token(CC_ELSIF);
3249 ConditionalOrExpression();
3250 jj_consume_token(CC_THEN);
3251 label_10:
3252 while (true) {
3253 switch (jj_nt.kind) {
3254 case REPLACE:
3255 case DEFINER:
3256 case CURRENT_USER:
3257 case SERIALLY_REUSABLE:
3258 case RESTRICT_REFERENCES:
3259 case EXCEPTION_INIT:
3260 case AUTONOMOUS_TRANSACTION:
3261 case LANGUAGE:
3262 case ADD:
3263 case AGGREGATE:
3264 case ALL:
3265 case ALTER:
3266 case AND:
3267 case ANY:
3268 case ARRAY:
3269 case AS:
3270 case ASC:
3271 case AT:
3272 case ATTRIBUTE:
3273 case AUTHID:
3274 case AVG:
3275 case BETWEEN:
3276 case BINARY_INTEGER:
3277 case BODY:
3278 case BOOLEAN:
3279 case BULK:
3280 case BY:
3281 case BYTE:
3282 case CASCADE:
3283 case CASE:
3284 case CHAR:
3285 case CHAR_BASE:
3286 case CHECK:
3287 case CLOSE:
3288 case CLUSTER:
3289 case COALESCE:
3290 case COLLECT:
3291 case COLUMN:
3292 case COMMENT:
3293 case COMMIT:
3294 case COMPRESS:
3295 case CONNECT:
3296 case CONSTANT:
3297 case CONSTRUCTOR:
3298 case CONTINUE:
3299 case CONVERT:
3300 case CREATE:
3301 case CURRENT:
3302 case CURRVAL:
3303 case CURSOR:
3304 case DATA:
3305 case DATE:
3306 case DAY:
3307 case DECLARE:
3308 case DECIMAL:
3309 case _DEFAULT:
3310 case DELETE:
3311 case DESC:
3312 case DISABLE:
3313 case DISTINCT:
3314 case DO:
3315 case DROP:
3316 case EDITIONABLE:
3317 case ELEMENT:
3318 case ELSE:
3319 case ELSIF:
3320 case ENABLE:
3321 case ESCAPE:
3322 case EXCEPT:
3323 case EXCEPTION:
3324 case EXCEPTIONS:
3325 case EXCLUSIVE:
3326 case EXECUTE:
3327 case EXISTS:
3328 case EXIT:
3329 case EXTERNAL:
3330 case EXTENDS:
3331 case EXTRACT:
3332 case FALSE:
3333 case FETCH:
3334 case FINAL:
3335 case FLOAT:
3336 case FOR:
3337 case FORALL:
3338 case FORCE:
3339 case FROM:
3340 case FUNCTION:
3341 case GLOBAL:
3342 case GOTO:
3343 case GROUP:
3344 case HASH:
3345 case HAVING:
3346 case HEAP:
3347 case HOUR:
3348 case IF:
3349 case IMMEDIATE:
3350 case IN:
3351 case INDEX:
3352 case INDICES:
3353 case INDEXTYPE:
3354 case INDICATOR:
3355 case INSERT:
3356 case INSTANTIABLE:
3357 case INTEGER:
3358 case INTERFACE:
3359 case INTERSECT:
3360 case INTERVAL:
3361 case INTO:
3362 case INVALIDATE:
3363 case IS:
3364 case ISOLATION:
3365 case JAVA:
3366 case LEVEL:
3367 case LIKE:
3368 case LIMIT:
3369 case LIMITED:
3370 case LOCK:
3371 case LONG:
3372 case LOOP:
3373 case MAP:
3374 case MAX:
3375 case MEMBER:
3376 case MERGE:
3377 case MIN:
3378 case MINUS:
3379 case MINUTE:
3380 case MLSLABEL:
3381 case MODIFY:
3382 case MOD:
3383 case MODE:
3384 case MONTH:
3385 case NATURAL:
3386 case NATURALN:
3387 case NEW:
3388 case NEXTVAL:
3389 case NO:
3390 case NOCOPY:
3391 case NONEDITIONABLE:
3392 case NOT:
3393 case NOWAIT:
3394 case NULL:
3395 case NULLIF:
3396 case NUMBER:
3397 case BFILE_BASE:
3398 case BLOB_BASE:
3399 case CLOB_BASE:
3400 case DATE_BASE:
3401 case NUMBER_BASE:
3402 case OBJECT:
3403 case OCIROWID:
3404 case OF:
3405 case OID:
3406 case ON:
3407 case OPAQUE:
3408 case OPEN:
3409 case OPERATOR:
3410 case OPTION:
3411 case OR:
3412 case ORDER:
3413 case ORGANIZATION:
3414 case OTHERS:
3415 case OUT:
3416 case OVERRIDING:
3417 case PACKAGE:
3418 case PARTITION:
3419 case PCTFREE:
3420 case PLS_INTEGER:
3421 case POSITIVE:
3422 case POSITIVEN:
3423 case PRAGMA:
3424 case PRESERVE:
3425 case PRIOR:
3426 case PROMPT:
3427 case PRIVATE:
3428 case PROCEDURE:
3429 case PUBLIC:
3430 case RAISE:
3431 case RANGE:
3432 case RAW:
3433 case REAL:
3434 case RECORD:
3435 case REF:
3436 case RELEASE:
3437 case RELIES_ON:
3438 case RENAME:
3439 case RESULT:
3440 case RETURN:
3441 case RETURNING:
3442 case REVERSE:
3443 case ROLLBACK:
3444 case ROW:
3445 case ROWS:
3446 case ROWID:
3447 case ROWNUM:
3448 case ROWTYPE:
3449 case SAVE:
3450 case SAVEPOINT:
3451 case SECOND:
3452 case SELECT:
3453 case SELF:
3454 case SEPARATE:
3455 case SET:
3456 case SHARE:
3457 case SMALLINT:
3458 case SPACE:
3459 case SQL:
3460 case SQLCODE:
3461 case SQLERRM:
3462 case START:
3463 case STATIC:
3464 case STDDEV:
3465 case SUBTYPE:
3466 case SUBSTITUTABLE:
3467 case SUCCESSFUL:
3468 case SUM:
3469 case SYNONYM:
3470 case SYSDATE:
3471 case SYS_REFCURSOR:
3472 case TABLE:
3473 case TEMPORARY:
3474 case THEN:
3475 case TIME:
3476 case TIMESTAMP:
3477 case TIMEZONE_REGION:
3478 case TIMEZONE_ABBR:
3479 case TIMEZONE_MINUTE:
3480 case TIMEZONE_HOUR:
3481 case TO:
3482 case TRANSACTION:
3483 case TRIGGER:
3484 case TRUE:
3485 case TYPE:
3486 case UI:
3487 case UNDER:
3488 case USING:
3489 case WHILE:
3490 case YES:
3491 case SHOW:
3492 case A:
3493 case UPDATE:
3494 case VARCHAR:
3495 case VARCHAR2:
3496 case DOUBLE:
3497 case DEC:
3498 case PRECISION:
3499 case INT:
3500 case NUMERIC:
3501 case SIGNTYPE:
3502 case NCHAR:
3503 case NVARCHAR2:
3504 case STRING:
3505 case UROWID:
3506 case VARRAY:
3507 case VARYING:
3508 case BFILE:
3509 case BLOB:
3510 case CLOB:
3511 case NCLOB:
3512 case YEAR:
3513 case LOCAL:
3514 case WITH:
3515 case ZONE:
3516 case CHARACTER:
3517 case AFTER:
3518 case BEFORE:
3519 case OLD:
3520 case PARENT:
3521 case CC_IF:
3522 case CC_ERROR:
3523 case ANALYZE:
3524 case ASSOCIATE:
3525 case AUDIT:
3526 case COMPOUND:
3527 case DATABASE:
3528 case CALL:
3529 case DDL:
3530 case DISASSOCIATE:
3531 case EACH:
3532 case FOLLOWS:
3533 case LOGOFF:
3534 case LOGON:
3535 case NESTED:
3536 case NOAUDIT:
3537 case SCHEMA:
3538 case SERVERERROR:
3539 case SHUTDOWN:
3540 case STARTUP:
3541 case STATEMENT:
3542 case STATISTICS:
3543 case SUSPEND:
3544 case TRUNCATE:
3545 case WRAPPED:
3546 case LIBRARY:
3547 case NAME:
3548 case STRUCT:
3549 case CONTEXT:
3550 case PARAMETERS:
3551 case LENGTH:
3552 case TDO:
3553 case MAXLEN:
3554 case CHARSETID:
3555 case CHARSETFORM:
3556 case ACCEPT:
3557 case ACCESSIBLE:
3558 case COPY:
3559 case DEFINE:
3560 case DISCONNECT:
3561 case HOST:
3562 case PRINT:
3563 case QUIT:
3564 case REMARK:
3565 case UNDEFINE:
3566 case VARIABLE:
3567 case WHENEVER:
3568 case ATTACH:
3569 case CAST:
3570 case TREAT:
3571 case TRIM:
3572 case LEFT:
3573 case RIGHT:
3574 case BOTH:
3575 case EMPTY:
3576 case MULTISET:
3577 case SUBMULTISET:
3578 case LEADING:
3579 case TRAILING:
3580 case CHAR_CS:
3581 case NCHAR_CS:
3582 case DBTIMEZONE:
3583 case SESSIONTIMEZONE:
3584 case AUTHENTICATED:
3585 case LINK:
3586 case SHARED:
3587 case DIRECTORY:
3588 case USER:
3589 case IDENTIFIER:
3590 case QUOTED_LITERAL:
3591 case SQLDATA_CLASS:
3592 case CUSTOMDATUM_CLASS:
3593 case ORADATA_CLASS:
3594 case JAVA_INTERFACE_CLASS:
3595 ;
3596 break;
3597 default:
3598 jj_la1[37] = jj_gen;
3599 break label_10;
3600 }
3601 switch (jj_nt.kind) {
3602 case REPLACE:
3603 case DEFINER:
3604 case CURRENT_USER:
3605 case SERIALLY_REUSABLE:
3606 case RESTRICT_REFERENCES:
3607 case EXCEPTION_INIT:
3608 case AUTONOMOUS_TRANSACTION:
3609 case LANGUAGE:
3610 case ADD:
3611 case AGGREGATE:
3612 case ALL:
3613 case ALTER:
3614 case AND:
3615 case ANY:
3616 case ARRAY:
3617 case AS:
3618 case ASC:
3619 case AT:
3620 case ATTRIBUTE:
3621 case AUTHID:
3622 case AVG:
3623 case BETWEEN:
3624 case BINARY_INTEGER:
3625 case BODY:
3626 case BOOLEAN:
3627 case BULK:
3628 case BY:
3629 case BYTE:
3630 case CASCADE:
3631 case CASE:
3632 case CHAR:
3633 case CHAR_BASE:
3634 case CHECK:
3635 case CLOSE:
3636 case CLUSTER:
3637 case COALESCE:
3638 case COLLECT:
3639 case COLUMN:
3640 case COMMENT:
3641 case COMMIT:
3642 case COMPRESS:
3643 case CONNECT:
3644 case CONSTANT:
3645 case CONSTRUCTOR:
3646 case CONTINUE:
3647 case CONVERT:
3648 case CREATE:
3649 case CURRENT:
3650 case CURRVAL:
3651 case CURSOR:
3652 case DATA:
3653 case DATE:
3654 case DAY:
3655 case DECLARE:
3656 case DECIMAL:
3657 case _DEFAULT:
3658 case DELETE:
3659 case DESC:
3660 case DISABLE:
3661 case DISTINCT:
3662 case DO:
3663 case DROP:
3664 case EDITIONABLE:
3665 case ELEMENT:
3666 case ELSE:
3667 case ELSIF:
3668 case ENABLE:
3669 case ESCAPE:
3670 case EXCEPT:
3671 case EXCEPTION:
3672 case EXCEPTIONS:
3673 case EXCLUSIVE:
3674 case EXECUTE:
3675 case EXISTS:
3676 case EXIT:
3677 case EXTERNAL:
3678 case EXTENDS:
3679 case EXTRACT:
3680 case FALSE:
3681 case FETCH:
3682 case FINAL:
3683 case FLOAT:
3684 case FOR:
3685 case FORALL:
3686 case FORCE:
3687 case FROM:
3688 case FUNCTION:
3689 case GLOBAL:
3690 case GOTO:
3691 case GROUP:
3692 case HASH:
3693 case HAVING:
3694 case HEAP:
3695 case HOUR:
3696 case IF:
3697 case IMMEDIATE:
3698 case IN:
3699 case INDEX:
3700 case INDICES:
3701 case INDEXTYPE:
3702 case INDICATOR:
3703 case INSERT:
3704 case INSTANTIABLE:
3705 case INTEGER:
3706 case INTERFACE:
3707 case INTERSECT:
3708 case INTERVAL:
3709 case INTO:
3710 case INVALIDATE:
3711 case IS:
3712 case ISOLATION:
3713 case JAVA:
3714 case LEVEL:
3715 case LIKE:
3716 case LIMIT:
3717 case LIMITED:
3718 case LOCK:
3719 case LONG:
3720 case LOOP:
3721 case MAP:
3722 case MAX:
3723 case MEMBER:
3724 case MERGE:
3725 case MIN:
3726 case MINUS:
3727 case MINUTE:
3728 case MLSLABEL:
3729 case MODIFY:
3730 case MOD:
3731 case MODE:
3732 case MONTH:
3733 case NATURAL:
3734 case NATURALN:
3735 case NEW:
3736 case NEXTVAL:
3737 case NO:
3738 case NOCOPY:
3739 case NONEDITIONABLE:
3740 case NOT:
3741 case NOWAIT:
3742 case NULL:
3743 case NULLIF:
3744 case NUMBER:
3745 case BFILE_BASE:
3746 case BLOB_BASE:
3747 case CLOB_BASE:
3748 case DATE_BASE:
3749 case NUMBER_BASE:
3750 case OBJECT:
3751 case OCIROWID:
3752 case OF:
3753 case OID:
3754 case ON:
3755 case OPAQUE:
3756 case OPEN:
3757 case OPERATOR:
3758 case OPTION:
3759 case OR:
3760 case ORDER:
3761 case ORGANIZATION:
3762 case OTHERS:
3763 case OUT:
3764 case OVERRIDING:
3765 case PACKAGE:
3766 case PARTITION:
3767 case PCTFREE:
3768 case PLS_INTEGER:
3769 case POSITIVE:
3770 case POSITIVEN:
3771 case PRAGMA:
3772 case PRESERVE:
3773 case PRIOR:
3774 case PROMPT:
3775 case PRIVATE:
3776 case PROCEDURE:
3777 case PUBLIC:
3778 case RAISE:
3779 case RANGE:
3780 case RAW:
3781 case REAL:
3782 case RECORD:
3783 case REF:
3784 case RELEASE:
3785 case RELIES_ON:
3786 case RENAME:
3787 case RESULT:
3788 case RETURN:
3789 case RETURNING:
3790 case REVERSE:
3791 case ROLLBACK:
3792 case ROW:
3793 case ROWS:
3794 case ROWID:
3795 case ROWNUM:
3796 case ROWTYPE:
3797 case SAVE:
3798 case SAVEPOINT:
3799 case SECOND:
3800 case SELECT:
3801 case SELF:
3802 case SEPARATE:
3803 case SET:
3804 case SHARE:
3805 case SMALLINT:
3806 case SPACE:
3807 case SQL:
3808 case SQLCODE:
3809 case SQLERRM:
3810 case START:
3811 case STATIC:
3812 case STDDEV:
3813 case SUBTYPE:
3814 case SUBSTITUTABLE:
3815 case SUCCESSFUL:
3816 case SUM:
3817 case SYNONYM:
3818 case SYSDATE:
3819 case SYS_REFCURSOR:
3820 case TABLE:
3821 case TEMPORARY:
3822 case THEN:
3823 case TIME:
3824 case TIMESTAMP:
3825 case TIMEZONE_REGION:
3826 case TIMEZONE_ABBR:
3827 case TIMEZONE_MINUTE:
3828 case TIMEZONE_HOUR:
3829 case TO:
3830 case TRANSACTION:
3831 case TRIGGER:
3832 case TRUE:
3833 case TYPE:
3834 case UI:
3835 case UNDER:
3836 case USING:
3837 case WHILE:
3838 case YES:
3839 case SHOW:
3840 case A:
3841 case UPDATE:
3842 case VARCHAR:
3843 case VARCHAR2:
3844 case DOUBLE:
3845 case DEC:
3846 case PRECISION:
3847 case INT:
3848 case NUMERIC:
3849 case SIGNTYPE:
3850 case NCHAR:
3851 case NVARCHAR2:
3852 case STRING:
3853 case UROWID:
3854 case VARRAY:
3855 case VARYING:
3856 case BFILE:
3857 case BLOB:
3858 case CLOB:
3859 case NCLOB:
3860 case YEAR:
3861 case LOCAL:
3862 case WITH:
3863 case ZONE:
3864 case CHARACTER:
3865 case AFTER:
3866 case BEFORE:
3867 case OLD:
3868 case PARENT:
3869 case CC_IF:
3870 case ANALYZE:
3871 case ASSOCIATE:
3872 case AUDIT:
3873 case COMPOUND:
3874 case DATABASE:
3875 case CALL:
3876 case DDL:
3877 case DISASSOCIATE:
3878 case EACH:
3879 case FOLLOWS:
3880 case LOGOFF:
3881 case LOGON:
3882 case NESTED:
3883 case NOAUDIT:
3884 case SCHEMA:
3885 case SERVERERROR:
3886 case SHUTDOWN:
3887 case STARTUP:
3888 case STATEMENT:
3889 case STATISTICS:
3890 case SUSPEND:
3891 case TRUNCATE:
3892 case WRAPPED:
3893 case LIBRARY:
3894 case NAME:
3895 case STRUCT:
3896 case CONTEXT:
3897 case PARAMETERS:
3898 case LENGTH:
3899 case TDO:
3900 case MAXLEN:
3901 case CHARSETID:
3902 case CHARSETFORM:
3903 case ACCEPT:
3904 case ACCESSIBLE:
3905 case COPY:
3906 case DEFINE:
3907 case DISCONNECT:
3908 case HOST:
3909 case PRINT:
3910 case QUIT:
3911 case REMARK:
3912 case UNDEFINE:
3913 case VARIABLE:
3914 case WHENEVER:
3915 case ATTACH:
3916 case CAST:
3917 case TREAT:
3918 case TRIM:
3919 case LEFT:
3920 case RIGHT:
3921 case BOTH:
3922 case EMPTY:
3923 case MULTISET:
3924 case SUBMULTISET:
3925 case LEADING:
3926 case TRAILING:
3927 case CHAR_CS:
3928 case NCHAR_CS:
3929 case DBTIMEZONE:
3930 case SESSIONTIMEZONE:
3931 case AUTHENTICATED:
3932 case LINK:
3933 case SHARED:
3934 case DIRECTORY:
3935 case USER:
3936 case IDENTIFIER:
3937 case QUOTED_LITERAL:
3938 case SQLDATA_CLASS:
3939 case CUSTOMDATUM_CLASS:
3940 case ORADATA_CLASS:
3941 case JAVA_INTERFACE_CLASS:
3942 DeclarativeUnit();
3943 break;
3944 case CC_ERROR:
3945 jj_consume_token(CC_ERROR);
3946 Expression();
3947 jj_consume_token(CC_END);
3948 break;
3949 default:
3950 jj_la1[38] = jj_gen;
3951 jj_consume_token(-1);
3952 throw new ParseException();
3953 }
3954 }
3955 }
3956 label_11:
3957 while (true) {
3958 switch (jj_nt.kind) {
3959 case CC_ELSE:
3960 ;
3961 break;
3962 default:
3963 jj_la1[39] = jj_gen;
3964 break label_11;
3965 }
3966 jj_consume_token(CC_ELSE);
3967 label_12:
3968 while (true) {
3969 switch (jj_nt.kind) {
3970 case REPLACE:
3971 case DEFINER:
3972 case CURRENT_USER:
3973 case SERIALLY_REUSABLE:
3974 case RESTRICT_REFERENCES:
3975 case EXCEPTION_INIT:
3976 case AUTONOMOUS_TRANSACTION:
3977 case LANGUAGE:
3978 case ADD:
3979 case AGGREGATE:
3980 case ALL:
3981 case ALTER:
3982 case AND:
3983 case ANY:
3984 case ARRAY:
3985 case AS:
3986 case ASC:
3987 case AT:
3988 case ATTRIBUTE:
3989 case AUTHID:
3990 case AVG:
3991 case BETWEEN:
3992 case BINARY_INTEGER:
3993 case BODY:
3994 case BOOLEAN:
3995 case BULK:
3996 case BY:
3997 case BYTE:
3998 case CASCADE:
3999 case CASE:
4000 case CHAR:
4001 case CHAR_BASE:
4002 case CHECK:
4003 case CLOSE:
4004 case CLUSTER:
4005 case COALESCE:
4006 case COLLECT:
4007 case COLUMN:
4008 case COMMENT:
4009 case COMMIT:
4010 case COMPRESS:
4011 case CONNECT:
4012 case CONSTANT:
4013 case CONSTRUCTOR:
4014 case CONTINUE:
4015 case CONVERT:
4016 case CREATE:
4017 case CURRENT:
4018 case CURRVAL:
4019 case CURSOR:
4020 case DATA:
4021 case DATE:
4022 case DAY:
4023 case DECLARE:
4024 case DECIMAL:
4025 case _DEFAULT:
4026 case DELETE:
4027 case DESC:
4028 case DISABLE:
4029 case DISTINCT:
4030 case DO:
4031 case DROP:
4032 case EDITIONABLE:
4033 case ELEMENT:
4034 case ELSE:
4035 case ELSIF:
4036 case ENABLE:
4037 case ESCAPE:
4038 case EXCEPT:
4039 case EXCEPTION:
4040 case EXCEPTIONS:
4041 case EXCLUSIVE:
4042 case EXECUTE:
4043 case EXISTS:
4044 case EXIT:
4045 case EXTERNAL:
4046 case EXTENDS:
4047 case EXTRACT:
4048 case FALSE:
4049 case FETCH:
4050 case FINAL:
4051 case FLOAT:
4052 case FOR:
4053 case FORALL:
4054 case FORCE:
4055 case FROM:
4056 case FUNCTION:
4057 case GLOBAL:
4058 case GOTO:
4059 case GROUP:
4060 case HASH:
4061 case HAVING:
4062 case HEAP:
4063 case HOUR:
4064 case IF:
4065 case IMMEDIATE:
4066 case IN:
4067 case INDEX:
4068 case INDICES:
4069 case INDEXTYPE:
4070 case INDICATOR:
4071 case INSERT:
4072 case INSTANTIABLE:
4073 case INTEGER:
4074 case INTERFACE:
4075 case INTERSECT:
4076 case INTERVAL:
4077 case INTO:
4078 case INVALIDATE:
4079 case IS:
4080 case ISOLATION:
4081 case JAVA:
4082 case LEVEL:
4083 case LIKE:
4084 case LIMIT:
4085 case LIMITED:
4086 case LOCK:
4087 case LONG:
4088 case LOOP:
4089 case MAP:
4090 case MAX:
4091 case MEMBER:
4092 case MERGE:
4093 case MIN:
4094 case MINUS:
4095 case MINUTE:
4096 case MLSLABEL:
4097 case MODIFY:
4098 case MOD:
4099 case MODE:
4100 case MONTH:
4101 case NATURAL:
4102 case NATURALN:
4103 case NEW:
4104 case NEXTVAL:
4105 case NO:
4106 case NOCOPY:
4107 case NONEDITIONABLE:
4108 case NOT:
4109 case NOWAIT:
4110 case NULL:
4111 case NULLIF:
4112 case NUMBER:
4113 case BFILE_BASE:
4114 case BLOB_BASE:
4115 case CLOB_BASE:
4116 case DATE_BASE:
4117 case NUMBER_BASE:
4118 case OBJECT:
4119 case OCIROWID:
4120 case OF:
4121 case OID:
4122 case ON:
4123 case OPAQUE:
4124 case OPEN:
4125 case OPERATOR:
4126 case OPTION:
4127 case OR:
4128 case ORDER:
4129 case ORGANIZATION:
4130 case OTHERS:
4131 case OUT:
4132 case OVERRIDING:
4133 case PACKAGE:
4134 case PARTITION:
4135 case PCTFREE:
4136 case PLS_INTEGER:
4137 case POSITIVE:
4138 case POSITIVEN:
4139 case PRAGMA:
4140 case PRESERVE:
4141 case PRIOR:
4142 case PROMPT:
4143 case PRIVATE:
4144 case PROCEDURE:
4145 case PUBLIC:
4146 case RAISE:
4147 case RANGE:
4148 case RAW:
4149 case REAL:
4150 case RECORD:
4151 case REF:
4152 case RELEASE:
4153 case RELIES_ON:
4154 case RENAME:
4155 case RESULT:
4156 case RETURN:
4157 case RETURNING:
4158 case REVERSE:
4159 case ROLLBACK:
4160 case ROW:
4161 case ROWS:
4162 case ROWID:
4163 case ROWNUM:
4164 case ROWTYPE:
4165 case SAVE:
4166 case SAVEPOINT:
4167 case SECOND:
4168 case SELECT:
4169 case SELF:
4170 case SEPARATE:
4171 case SET:
4172 case SHARE:
4173 case SMALLINT:
4174 case SPACE:
4175 case SQL:
4176 case SQLCODE:
4177 case SQLERRM:
4178 case START:
4179 case STATIC:
4180 case STDDEV:
4181 case SUBTYPE:
4182 case SUBSTITUTABLE:
4183 case SUCCESSFUL:
4184 case SUM:
4185 case SYNONYM:
4186 case SYSDATE:
4187 case SYS_REFCURSOR:
4188 case TABLE:
4189 case TEMPORARY:
4190 case THEN:
4191 case TIME:
4192 case TIMESTAMP:
4193 case TIMEZONE_REGION:
4194 case TIMEZONE_ABBR:
4195 case TIMEZONE_MINUTE:
4196 case TIMEZONE_HOUR:
4197 case TO:
4198 case TRANSACTION:
4199 case TRIGGER:
4200 case TRUE:
4201 case TYPE:
4202 case UI:
4203 case UNDER:
4204 case USING:
4205 case WHILE:
4206 case YES:
4207 case SHOW:
4208 case A:
4209 case UPDATE:
4210 case VARCHAR:
4211 case VARCHAR2:
4212 case DOUBLE:
4213 case DEC:
4214 case PRECISION:
4215 case INT:
4216 case NUMERIC:
4217 case SIGNTYPE:
4218 case NCHAR:
4219 case NVARCHAR2:
4220 case STRING:
4221 case UROWID:
4222 case VARRAY:
4223 case VARYING:
4224 case BFILE:
4225 case BLOB:
4226 case CLOB:
4227 case NCLOB:
4228 case YEAR:
4229 case LOCAL:
4230 case WITH:
4231 case ZONE:
4232 case CHARACTER:
4233 case AFTER:
4234 case BEFORE:
4235 case OLD:
4236 case PARENT:
4237 case CC_IF:
4238 case CC_ERROR:
4239 case ANALYZE:
4240 case ASSOCIATE:
4241 case AUDIT:
4242 case COMPOUND:
4243 case DATABASE:
4244 case CALL:
4245 case DDL:
4246 case DISASSOCIATE:
4247 case EACH:
4248 case FOLLOWS:
4249 case LOGOFF:
4250 case LOGON:
4251 case NESTED:
4252 case NOAUDIT:
4253 case SCHEMA:
4254 case SERVERERROR:
4255 case SHUTDOWN:
4256 case STARTUP:
4257 case STATEMENT:
4258 case STATISTICS:
4259 case SUSPEND:
4260 case TRUNCATE:
4261 case WRAPPED:
4262 case LIBRARY:
4263 case NAME:
4264 case STRUCT:
4265 case CONTEXT:
4266 case PARAMETERS:
4267 case LENGTH:
4268 case TDO:
4269 case MAXLEN:
4270 case CHARSETID:
4271 case CHARSETFORM:
4272 case ACCEPT:
4273 case ACCESSIBLE:
4274 case COPY:
4275 case DEFINE:
4276 case DISCONNECT:
4277 case HOST:
4278 case PRINT:
4279 case QUIT:
4280 case REMARK:
4281 case UNDEFINE:
4282 case VARIABLE:
4283 case WHENEVER:
4284 case ATTACH:
4285 case CAST:
4286 case TREAT:
4287 case TRIM:
4288 case LEFT:
4289 case RIGHT:
4290 case BOTH:
4291 case EMPTY:
4292 case MULTISET:
4293 case SUBMULTISET:
4294 case LEADING:
4295 case TRAILING:
4296 case CHAR_CS:
4297 case NCHAR_CS:
4298 case DBTIMEZONE:
4299 case SESSIONTIMEZONE:
4300 case AUTHENTICATED:
4301 case LINK:
4302 case SHARED:
4303 case DIRECTORY:
4304 case USER:
4305 case IDENTIFIER:
4306 case QUOTED_LITERAL:
4307 case SQLDATA_CLASS:
4308 case CUSTOMDATUM_CLASS:
4309 case ORADATA_CLASS:
4310 case JAVA_INTERFACE_CLASS:
4311 ;
4312 break;
4313 default:
4314 jj_la1[40] = jj_gen;
4315 break label_12;
4316 }
4317 switch (jj_nt.kind) {
4318 case REPLACE:
4319 case DEFINER:
4320 case CURRENT_USER:
4321 case SERIALLY_REUSABLE:
4322 case RESTRICT_REFERENCES:
4323 case EXCEPTION_INIT:
4324 case AUTONOMOUS_TRANSACTION:
4325 case LANGUAGE:
4326 case ADD:
4327 case AGGREGATE:
4328 case ALL:
4329 case ALTER:
4330 case AND:
4331 case ANY:
4332 case ARRAY:
4333 case AS:
4334 case ASC:
4335 case AT:
4336 case ATTRIBUTE:
4337 case AUTHID:
4338 case AVG:
4339 case BETWEEN:
4340 case BINARY_INTEGER:
4341 case BODY:
4342 case BOOLEAN:
4343 case BULK:
4344 case BY:
4345 case BYTE:
4346 case CASCADE:
4347 case CASE:
4348 case CHAR:
4349 case CHAR_BASE:
4350 case CHECK:
4351 case CLOSE:
4352 case CLUSTER:
4353 case COALESCE:
4354 case COLLECT:
4355 case COLUMN:
4356 case COMMENT:
4357 case COMMIT:
4358 case COMPRESS:
4359 case CONNECT:
4360 case CONSTANT:
4361 case CONSTRUCTOR:
4362 case CONTINUE:
4363 case CONVERT:
4364 case CREATE:
4365 case CURRENT:
4366 case CURRVAL:
4367 case CURSOR:
4368 case DATA:
4369 case DATE:
4370 case DAY:
4371 case DECLARE:
4372 case DECIMAL:
4373 case _DEFAULT:
4374 case DELETE:
4375 case DESC:
4376 case DISABLE:
4377 case DISTINCT:
4378 case DO:
4379 case DROP:
4380 case EDITIONABLE:
4381 case ELEMENT:
4382 case ELSE:
4383 case ELSIF:
4384 case ENABLE:
4385 case ESCAPE:
4386 case EXCEPT:
4387 case EXCEPTION:
4388 case EXCEPTIONS:
4389 case EXCLUSIVE:
4390 case EXECUTE:
4391 case EXISTS:
4392 case EXIT:
4393 case EXTERNAL:
4394 case EXTENDS:
4395 case EXTRACT:
4396 case FALSE:
4397 case FETCH:
4398 case FINAL:
4399 case FLOAT:
4400 case FOR:
4401 case FORALL:
4402 case FORCE:
4403 case FROM:
4404 case FUNCTION:
4405 case GLOBAL:
4406 case GOTO:
4407 case GROUP:
4408 case HASH:
4409 case HAVING:
4410 case HEAP:
4411 case HOUR:
4412 case IF:
4413 case IMMEDIATE:
4414 case IN:
4415 case INDEX:
4416 case INDICES:
4417 case INDEXTYPE:
4418 case INDICATOR:
4419 case INSERT:
4420 case INSTANTIABLE:
4421 case INTEGER:
4422 case INTERFACE:
4423 case INTERSECT:
4424 case INTERVAL:
4425 case INTO:
4426 case INVALIDATE:
4427 case IS:
4428 case ISOLATION:
4429 case JAVA:
4430 case LEVEL:
4431 case LIKE:
4432 case LIMIT:
4433 case LIMITED:
4434 case LOCK:
4435 case LONG:
4436 case LOOP:
4437 case MAP:
4438 case MAX:
4439 case MEMBER:
4440 case MERGE:
4441 case MIN:
4442 case MINUS:
4443 case MINUTE:
4444 case MLSLABEL:
4445 case MODIFY:
4446 case MOD:
4447 case MODE:
4448 case MONTH:
4449 case NATURAL:
4450 case NATURALN:
4451 case NEW:
4452 case NEXTVAL:
4453 case NO:
4454 case NOCOPY:
4455 case NONEDITIONABLE:
4456 case NOT:
4457 case NOWAIT:
4458 case NULL:
4459 case NULLIF:
4460 case NUMBER:
4461 case BFILE_BASE:
4462 case BLOB_BASE:
4463 case CLOB_BASE:
4464 case DATE_BASE:
4465 case NUMBER_BASE:
4466 case OBJECT:
4467 case OCIROWID:
4468 case OF:
4469 case OID:
4470 case ON:
4471 case OPAQUE:
4472 case OPEN:
4473 case OPERATOR:
4474 case OPTION:
4475 case OR:
4476 case ORDER:
4477 case ORGANIZATION:
4478 case OTHERS:
4479 case OUT:
4480 case OVERRIDING:
4481 case PACKAGE:
4482 case PARTITION:
4483 case PCTFREE:
4484 case PLS_INTEGER:
4485 case POSITIVE:
4486 case POSITIVEN:
4487 case PRAGMA:
4488 case PRESERVE:
4489 case PRIOR:
4490 case PROMPT:
4491 case PRIVATE:
4492 case PROCEDURE:
4493 case PUBLIC:
4494 case RAISE:
4495 case RANGE:
4496 case RAW:
4497 case REAL:
4498 case RECORD:
4499 case REF:
4500 case RELEASE:
4501 case RELIES_ON:
4502 case RENAME:
4503 case RESULT:
4504 case RETURN:
4505 case RETURNING:
4506 case REVERSE:
4507 case ROLLBACK:
4508 case ROW:
4509 case ROWS:
4510 case ROWID:
4511 case ROWNUM:
4512 case ROWTYPE:
4513 case SAVE:
4514 case SAVEPOINT:
4515 case SECOND:
4516 case SELECT:
4517 case SELF:
4518 case SEPARATE:
4519 case SET:
4520 case SHARE:
4521 case SMALLINT:
4522 case SPACE:
4523 case SQL:
4524 case SQLCODE:
4525 case SQLERRM:
4526 case START:
4527 case STATIC:
4528 case STDDEV:
4529 case SUBTYPE:
4530 case SUBSTITUTABLE:
4531 case SUCCESSFUL:
4532 case SUM:
4533 case SYNONYM:
4534 case SYSDATE:
4535 case SYS_REFCURSOR:
4536 case TABLE:
4537 case TEMPORARY:
4538 case THEN:
4539 case TIME:
4540 case TIMESTAMP:
4541 case TIMEZONE_REGION:
4542 case TIMEZONE_ABBR:
4543 case TIMEZONE_MINUTE:
4544 case TIMEZONE_HOUR:
4545 case TO:
4546 case TRANSACTION:
4547 case TRIGGER:
4548 case TRUE:
4549 case TYPE:
4550 case UI:
4551 case UNDER:
4552 case USING:
4553 case WHILE:
4554 case YES:
4555 case SHOW:
4556 case A:
4557 case UPDATE:
4558 case VARCHAR:
4559 case VARCHAR2:
4560 case DOUBLE:
4561 case DEC:
4562 case PRECISION:
4563 case INT:
4564 case NUMERIC:
4565 case SIGNTYPE:
4566 case NCHAR:
4567 case NVARCHAR2:
4568 case STRING:
4569 case UROWID:
4570 case VARRAY:
4571 case VARYING:
4572 case BFILE:
4573 case BLOB:
4574 case CLOB:
4575 case NCLOB:
4576 case YEAR:
4577 case LOCAL:
4578 case WITH:
4579 case ZONE:
4580 case CHARACTER:
4581 case AFTER:
4582 case BEFORE:
4583 case OLD:
4584 case PARENT:
4585 case CC_IF:
4586 case ANALYZE:
4587 case ASSOCIATE:
4588 case AUDIT:
4589 case COMPOUND:
4590 case DATABASE:
4591 case CALL:
4592 case DDL:
4593 case DISASSOCIATE:
4594 case EACH:
4595 case FOLLOWS:
4596 case LOGOFF:
4597 case LOGON:
4598 case NESTED:
4599 case NOAUDIT:
4600 case SCHEMA:
4601 case SERVERERROR:
4602 case SHUTDOWN:
4603 case STARTUP:
4604 case STATEMENT:
4605 case STATISTICS:
4606 case SUSPEND:
4607 case TRUNCATE:
4608 case WRAPPED:
4609 case LIBRARY:
4610 case NAME:
4611 case STRUCT:
4612 case CONTEXT:
4613 case PARAMETERS:
4614 case LENGTH:
4615 case TDO:
4616 case MAXLEN:
4617 case CHARSETID:
4618 case CHARSETFORM:
4619 case ACCEPT:
4620 case ACCESSIBLE:
4621 case COPY:
4622 case DEFINE:
4623 case DISCONNECT:
4624 case HOST:
4625 case PRINT:
4626 case QUIT:
4627 case REMARK:
4628 case UNDEFINE:
4629 case VARIABLE:
4630 case WHENEVER:
4631 case ATTACH:
4632 case CAST:
4633 case TREAT:
4634 case TRIM:
4635 case LEFT:
4636 case RIGHT:
4637 case BOTH:
4638 case EMPTY:
4639 case MULTISET:
4640 case SUBMULTISET:
4641 case LEADING:
4642 case TRAILING:
4643 case CHAR_CS:
4644 case NCHAR_CS:
4645 case DBTIMEZONE:
4646 case SESSIONTIMEZONE:
4647 case AUTHENTICATED:
4648 case LINK:
4649 case SHARED:
4650 case DIRECTORY:
4651 case USER:
4652 case IDENTIFIER:
4653 case QUOTED_LITERAL:
4654 case SQLDATA_CLASS:
4655 case CUSTOMDATUM_CLASS:
4656 case ORADATA_CLASS:
4657 case JAVA_INTERFACE_CLASS:
4658 DeclarativeUnit();
4659 break;
4660 case CC_ERROR:
4661 jj_consume_token(CC_ERROR);
4662 Expression();
4663 jj_consume_token(CC_END);
4664 break;
4665 default:
4666 jj_la1[41] = jj_gen;
4667 jj_consume_token(-1);
4668 throw new ParseException();
4669 }
4670 }
4671 }
4672 jj_consume_token(CC_END);
4673 jjtree.closeNodeScope(jjtn000, true);
4674 jjtc000 = false;
4675 {if (true) return jjtn000 ;}
4676 } catch (Throwable jjte000) {
4677 if (jjtc000) {
4678 jjtree.clearNodeScope(jjtn000);
4679 jjtc000 = false;
4680 } else {
4681 jjtree.popNode();
4682 }
4683 if (jjte000 instanceof RuntimeException) {
4684 {if (true) throw (RuntimeException)jjte000;}
4685 }
4686 if (jjte000 instanceof ParseException) {
4687 {if (true) throw (ParseException)jjte000;}
4688 }
4689 {if (true) throw (Error)jjte000;}
4690 } finally {
4691 if (jjtc000) {
4692 jjtree.closeNodeScope(jjtn000, true);
4693 }
4694 }
4695 throw new Error("Missing return statement in function");
4696 }
4697
4698
4699
4700
4701
4702
4703
4704 final public ASTProgramUnit ProgramUnit() throws ParseException {
4705
4706 ASTProgramUnit jjtn000 = new ASTProgramUnit(this, JJTPROGRAMUNIT);
4707 boolean jjtc000 = true;
4708 jjtree.openNodeScope(jjtn000);
4709 try {
4710 switch (jj_nt.kind) {
4711 case CREATE:
4712 jj_consume_token(CREATE);
4713 switch (jj_nt.kind) {
4714 case OR:
4715 jj_consume_token(OR);
4716 jj_consume_token(REPLACE);
4717 break;
4718 default:
4719 jj_la1[42] = jj_gen;
4720 ;
4721 }
4722 switch (jj_nt.kind) {
4723 case EDITIONABLE:
4724 case NONEDITIONABLE:
4725 switch (jj_nt.kind) {
4726 case EDITIONABLE:
4727 jj_consume_token(EDITIONABLE);
4728 break;
4729 case NONEDITIONABLE:
4730 jj_consume_token(NONEDITIONABLE);
4731 break;
4732 default:
4733 jj_la1[43] = jj_gen;
4734 jj_consume_token(-1);
4735 throw new ParseException();
4736 }
4737 break;
4738 default:
4739 jj_la1[44] = jj_gen;
4740 ;
4741 }
4742 break;
4743 default:
4744 jj_la1[45] = jj_gen;
4745 ;
4746 }
4747 MethodDeclarator();
4748 switch (jj_nt.kind) {
4749 case WRAPPED:
4750 WrappedObject();
4751 break;
4752 case 4:
4753 case AGGREGATE:
4754 case AS:
4755 case AUTHID:
4756 case DETERMINISTIC:
4757 case IS:
4758 case PARALLEL_ENABLE:
4759 case PIPELINED:
4760 case RESULT_CACHE:
4761 case ACCESSIBLE:
4762 label_13:
4763 while (true) {
4764 switch (jj_nt.kind) {
4765 case AUTHID:
4766 case DETERMINISTIC:
4767 case PARALLEL_ENABLE:
4768 case PIPELINED:
4769 case RESULT_CACHE:
4770 case ACCESSIBLE:
4771 ;
4772 break;
4773 default:
4774 jj_la1[46] = jj_gen;
4775 break label_13;
4776 }
4777 switch (jj_nt.kind) {
4778 case AUTHID:
4779 jj_consume_token(AUTHID);
4780 switch (jj_nt.kind) {
4781 case CURRENT_USER:
4782 jj_consume_token(CURRENT_USER);
4783 break;
4784 case DEFINER:
4785 jj_consume_token(DEFINER);
4786 break;
4787 default:
4788 jj_la1[47] = jj_gen;
4789 jj_consume_token(-1);
4790 throw new ParseException();
4791 }
4792 break;
4793 case DETERMINISTIC:
4794 jj_consume_token(DETERMINISTIC);
4795 break;
4796 case ACCESSIBLE:
4797 AccessibleByClause();
4798 break;
4799 case PARALLEL_ENABLE:
4800 jj_consume_token(PARALLEL_ENABLE);
4801 switch (jj_nt.kind) {
4802 case 5:
4803 ParallelClause();
4804 break;
4805 default:
4806 jj_la1[48] = jj_gen;
4807 ;
4808 }
4809 switch (jj_nt.kind) {
4810 case USING:
4811 jj_consume_token(USING);
4812 ID();
4813 switch (jj_nt.kind) {
4814 case 3:
4815 jj_consume_token(3);
4816 ID();
4817 break;
4818 default:
4819 jj_la1[49] = jj_gen;
4820 ;
4821 }
4822 break;
4823 default:
4824 jj_la1[50] = jj_gen;
4825 ;
4826 }
4827 break;
4828 case PIPELINED:
4829 jj_consume_token(PIPELINED);
4830 switch (jj_nt.kind) {
4831 case CLUSTER:
4832 case ORDER:
4833 case USING:
4834 switch (jj_nt.kind) {
4835 case USING:
4836 jj_consume_token(USING);
4837 ID();
4838 switch (jj_nt.kind) {
4839 case 3:
4840 jj_consume_token(3);
4841 ID();
4842 break;
4843 default:
4844 jj_la1[51] = jj_gen;
4845 ;
4846 }
4847 break;
4848 case CLUSTER:
4849 case ORDER:
4850 switch (jj_nt.kind) {
4851 case ORDER:
4852 jj_consume_token(ORDER);
4853 break;
4854 case CLUSTER:
4855 jj_consume_token(CLUSTER);
4856 break;
4857 default:
4858 jj_la1[52] = jj_gen;
4859 jj_consume_token(-1);
4860 throw new ParseException();
4861 }
4862 switch (jj_nt.kind) {
4863 case REPLACE:
4864 case DEFINER:
4865 case CURRENT_USER:
4866 case SERIALLY_REUSABLE:
4867 case RESTRICT_REFERENCES:
4868 case EXCEPTION_INIT:
4869 case AUTONOMOUS_TRANSACTION:
4870 case LANGUAGE:
4871 case ADD:
4872 case AGGREGATE:
4873 case ALL:
4874 case ALTER:
4875 case AND:
4876 case ANY:
4877 case ARRAY:
4878 case AS:
4879 case ASC:
4880 case AT:
4881 case ATTRIBUTE:
4882 case AUTHID:
4883 case AVG:
4884 case BETWEEN:
4885 case BINARY_INTEGER:
4886 case BODY:
4887 case BOOLEAN:
4888 case BULK:
4889 case BY:
4890 case BYTE:
4891 case CASCADE:
4892 case CASE:
4893 case CHAR:
4894 case CHAR_BASE:
4895 case CHECK:
4896 case CLOSE:
4897 case CLUSTER:
4898 case COALESCE:
4899 case COLLECT:
4900 case COLUMN:
4901 case COMMENT:
4902 case COMMIT:
4903 case COMPRESS:
4904 case CONNECT:
4905 case CONSTANT:
4906 case CONSTRUCTOR:
4907 case CONTINUE:
4908 case CONVERT:
4909 case CREATE:
4910 case CURRENT:
4911 case CURRVAL:
4912 case CURSOR:
4913 case DATA:
4914 case DATE:
4915 case DAY:
4916 case DECLARE:
4917 case DECIMAL:
4918 case _DEFAULT:
4919 case DELETE:
4920 case DESC:
4921 case DISABLE:
4922 case DISTINCT:
4923 case DO:
4924 case DROP:
4925 case EDITIONABLE:
4926 case ELEMENT:
4927 case ELSE:
4928 case ELSIF:
4929 case ENABLE:
4930 case ESCAPE:
4931 case EXCEPT:
4932 case EXCEPTION:
4933 case EXCEPTIONS:
4934 case EXCLUSIVE:
4935 case EXECUTE:
4936 case EXISTS:
4937 case EXIT:
4938 case EXTERNAL:
4939 case EXTENDS:
4940 case EXTRACT:
4941 case FALSE:
4942 case FETCH:
4943 case FINAL:
4944 case FLOAT:
4945 case FOR:
4946 case FORALL:
4947 case FORCE:
4948 case FROM:
4949 case FUNCTION:
4950 case GLOBAL:
4951 case GOTO:
4952 case GROUP:
4953 case HASH:
4954 case HAVING:
4955 case HEAP:
4956 case HOUR:
4957 case IF:
4958 case IMMEDIATE:
4959 case IN:
4960 case INDEX:
4961 case INDICES:
4962 case INDEXTYPE:
4963 case INDICATOR:
4964 case INSERT:
4965 case INSTANTIABLE:
4966 case INTEGER:
4967 case INTERFACE:
4968 case INTERSECT:
4969 case INTERVAL:
4970 case INTO:
4971 case INVALIDATE:
4972 case IS:
4973 case ISOLATION:
4974 case JAVA:
4975 case LEVEL:
4976 case LIKE:
4977 case LIMIT:
4978 case LIMITED:
4979 case LOCK:
4980 case LONG:
4981 case LOOP:
4982 case MAP:
4983 case MAX:
4984 case MEMBER:
4985 case MERGE:
4986 case MIN:
4987 case MINUS:
4988 case MINUTE:
4989 case MLSLABEL:
4990 case MODIFY:
4991 case MOD:
4992 case MODE:
4993 case MONTH:
4994 case NATURAL:
4995 case NATURALN:
4996 case NEW:
4997 case NEXTVAL:
4998 case NO:
4999 case NOCOPY:
5000 case NONEDITIONABLE:
5001 case NOT:
5002 case NOWAIT:
5003 case NULL:
5004 case NULLIF:
5005 case NUMBER:
5006 case BFILE_BASE:
5007 case BLOB_BASE:
5008 case CLOB_BASE:
5009 case DATE_BASE:
5010 case NUMBER_BASE:
5011 case OBJECT:
5012 case OCIROWID:
5013 case OF:
5014 case OID:
5015 case ON:
5016 case OPAQUE:
5017 case OPEN:
5018 case OPERATOR:
5019 case OPTION:
5020 case OR:
5021 case ORDER:
5022 case ORGANIZATION:
5023 case OTHERS:
5024 case OUT:
5025 case OVERRIDING:
5026 case PACKAGE:
5027 case PARTITION:
5028 case PCTFREE:
5029 case PLS_INTEGER:
5030 case POSITIVE:
5031 case POSITIVEN:
5032 case PRESERVE:
5033 case PRIOR:
5034 case PROMPT:
5035 case PRIVATE:
5036 case PROCEDURE:
5037 case PUBLIC:
5038 case RAISE:
5039 case RANGE:
5040 case RAW:
5041 case REAL:
5042 case RECORD:
5043 case REF:
5044 case RELEASE:
5045 case RELIES_ON:
5046 case RENAME:
5047 case RESULT:
5048 case RETURN:
5049 case RETURNING:
5050 case REVERSE:
5051 case ROLLBACK:
5052 case ROW:
5053 case ROWS:
5054 case ROWID:
5055 case ROWNUM:
5056 case ROWTYPE:
5057 case SAVE:
5058 case SAVEPOINT:
5059 case SECOND:
5060 case SELECT:
5061 case SELF:
5062 case SEPARATE:
5063 case SET:
5064 case SHARE:
5065 case SMALLINT:
5066 case SPACE:
5067 case SQL:
5068 case SQLCODE:
5069 case SQLERRM:
5070 case START:
5071 case STATIC:
5072 case STDDEV:
5073 case SUBTYPE:
5074 case SUBSTITUTABLE:
5075 case SUCCESSFUL:
5076 case SUM:
5077 case SYNONYM:
5078 case SYSDATE:
5079 case SYS_REFCURSOR:
5080 case TABLE:
5081 case TEMPORARY:
5082 case THEN:
5083 case TIME:
5084 case TIMESTAMP:
5085 case TIMEZONE_REGION:
5086 case TIMEZONE_ABBR:
5087 case TIMEZONE_MINUTE:
5088 case TIMEZONE_HOUR:
5089 case TO:
5090 case TRANSACTION:
5091 case TRIGGER:
5092 case TRUE:
5093 case TYPE:
5094 case UI:
5095 case UNDER:
5096 case USING:
5097 case WHILE:
5098 case YES:
5099 case SHOW:
5100 case A:
5101 case UPDATE:
5102 case VARCHAR:
5103 case VARCHAR2:
5104 case DOUBLE:
5105 case DEC:
5106 case PRECISION:
5107 case INT:
5108 case NUMERIC:
5109 case SIGNTYPE:
5110 case NCHAR:
5111 case NVARCHAR2:
5112 case STRING:
5113 case UROWID:
5114 case VARRAY:
5115 case VARYING:
5116 case BFILE:
5117 case BLOB:
5118 case CLOB:
5119 case NCLOB:
5120 case YEAR:
5121 case LOCAL:
5122 case WITH:
5123 case ZONE:
5124 case CHARACTER:
5125 case AFTER:
5126 case BEFORE:
5127 case OLD:
5128 case PARENT:
5129 case ANALYZE:
5130 case ASSOCIATE:
5131 case AUDIT:
5132 case COMPOUND:
5133 case DATABASE:
5134 case CALL:
5135 case DDL:
5136 case DISASSOCIATE:
5137 case EACH:
5138 case FOLLOWS:
5139 case LOGOFF:
5140 case LOGON:
5141 case NESTED:
5142 case NOAUDIT:
5143 case SCHEMA:
5144 case SERVERERROR:
5145 case SHUTDOWN:
5146 case STARTUP:
5147 case STATEMENT:
5148 case STATISTICS:
5149 case SUSPEND:
5150 case TRUNCATE:
5151 case WRAPPED:
5152 case LIBRARY:
5153 case NAME:
5154 case STRUCT:
5155 case CONTEXT:
5156 case PARAMETERS:
5157 case LENGTH:
5158 case TDO:
5159 case MAXLEN:
5160 case CHARSETID:
5161 case CHARSETFORM:
5162 case ACCEPT:
5163 case ACCESSIBLE:
5164 case COPY:
5165 case DEFINE:
5166 case DISCONNECT:
5167 case HOST:
5168 case PRINT:
5169 case QUIT:
5170 case REMARK:
5171 case UNDEFINE:
5172 case VARIABLE:
5173 case WHENEVER:
5174 case ATTACH:
5175 case CAST:
5176 case TREAT:
5177 case TRIM:
5178 case LEFT:
5179 case RIGHT:
5180 case BOTH:
5181 case EMPTY:
5182 case MULTISET:
5183 case SUBMULTISET:
5184 case LEADING:
5185 case TRAILING:
5186 case CHAR_CS:
5187 case NCHAR_CS:
5188 case DBTIMEZONE:
5189 case SESSIONTIMEZONE:
5190 case AUTHENTICATED:
5191 case LINK:
5192 case SHARED:
5193 case DIRECTORY:
5194 case USER:
5195 case IDENTIFIER:
5196 case QUOTED_LITERAL:
5197 case SQLDATA_CLASS:
5198 case CUSTOMDATUM_CLASS:
5199 case ORADATA_CLASS:
5200 case JAVA_INTERFACE_CLASS:
5201 ID();
5202 break;
5203 default:
5204 jj_la1[53] = jj_gen;
5205 ;
5206 }
5207 jj_consume_token(BY);
5208 jj_consume_token(5);
5209 ID();
5210 label_14:
5211 while (true) {
5212 switch (jj_nt.kind) {
5213 case 6:
5214 ;
5215 break;
5216 default:
5217 jj_la1[54] = jj_gen;
5218 break label_14;
5219 }
5220 jj_consume_token(6);
5221 ID();
5222 }
5223 jj_consume_token(7);
5224 break;
5225 default:
5226 jj_la1[55] = jj_gen;
5227 jj_consume_token(-1);
5228 throw new ParseException();
5229 }
5230 break;
5231 default:
5232 jj_la1[56] = jj_gen;
5233 ;
5234 }
5235 break;
5236 case RESULT_CACHE:
5237 jj_consume_token(RESULT_CACHE);
5238 switch (jj_nt.kind) {
5239 case RELIES_ON:
5240 jj_consume_token(RELIES_ON);
5241 jj_consume_token(5);
5242 ID();
5243 switch (jj_nt.kind) {
5244 case 3:
5245 jj_consume_token(3);
5246 ID();
5247 break;
5248 default:
5249 jj_la1[57] = jj_gen;
5250 ;
5251 }
5252 label_15:
5253 while (true) {
5254 switch (jj_nt.kind) {
5255 case 6:
5256 ;
5257 break;
5258 default:
5259 jj_la1[58] = jj_gen;
5260 break label_15;
5261 }
5262 jj_consume_token(6);
5263 ID();
5264 switch (jj_nt.kind) {
5265 case 3:
5266 jj_consume_token(3);
5267 ID();
5268 break;
5269 default:
5270 jj_la1[59] = jj_gen;
5271 ;
5272 }
5273 }
5274 jj_consume_token(7);
5275 break;
5276 default:
5277 jj_la1[60] = jj_gen;
5278 ;
5279 }
5280 break;
5281 default:
5282 jj_la1[61] = jj_gen;
5283 jj_consume_token(-1);
5284 throw new ParseException();
5285 }
5286 }
5287 switch (jj_nt.kind) {
5288 case AGGREGATE:
5289 jj_consume_token(AGGREGATE);
5290 jj_consume_token(USING);
5291 ID();
5292 break;
5293 default:
5294 jj_la1[62] = jj_gen;
5295 ;
5296 }
5297 switch (jj_nt.kind) {
5298 case AS:
5299 case IS:
5300 switch (jj_nt.kind) {
5301 case IS:
5302 jj_consume_token(IS);
5303 break;
5304 case AS:
5305 jj_consume_token(AS);
5306 break;
5307 default:
5308 jj_la1[63] = jj_gen;
5309 jj_consume_token(-1);
5310 throw new ParseException();
5311 }
5312 if (jj_2_21(2)) {
5313 CallSpecTail();
5314 } else {
5315 switch (jj_nt.kind) {
5316 case REPLACE:
5317 case DEFINER:
5318 case CURRENT_USER:
5319 case SERIALLY_REUSABLE:
5320 case RESTRICT_REFERENCES:
5321 case EXCEPTION_INIT:
5322 case AUTONOMOUS_TRANSACTION:
5323 case LANGUAGE:
5324 case ADD:
5325 case AGGREGATE:
5326 case ALL:
5327 case ALTER:
5328 case AND:
5329 case ANY:
5330 case ARRAY:
5331 case AS:
5332 case ASC:
5333 case AT:
5334 case ATTRIBUTE:
5335 case AUTHID:
5336 case AVG:
5337 case BEGIN:
5338 case BETWEEN:
5339 case BINARY_INTEGER:
5340 case BODY:
5341 case BOOLEAN:
5342 case BULK:
5343 case BY:
5344 case BYTE:
5345 case CASCADE:
5346 case CASE:
5347 case CHAR:
5348 case CHAR_BASE:
5349 case CHECK:
5350 case CLOSE:
5351 case CLUSTER:
5352 case COALESCE:
5353 case COLLECT:
5354 case COLUMN:
5355 case COMMENT:
5356 case COMMIT:
5357 case COMPRESS:
5358 case CONNECT:
5359 case CONSTANT:
5360 case CONSTRUCTOR:
5361 case CONTINUE:
5362 case CONVERT:
5363 case CREATE:
5364 case CURRENT:
5365 case CURRVAL:
5366 case CURSOR:
5367 case DATA:
5368 case DATE:
5369 case DAY:
5370 case DECLARE:
5371 case DECIMAL:
5372 case _DEFAULT:
5373 case DELETE:
5374 case DESC:
5375 case DISABLE:
5376 case DISTINCT:
5377 case DO:
5378 case DROP:
5379 case EDITIONABLE:
5380 case ELEMENT:
5381 case ELSE:
5382 case ELSIF:
5383 case ENABLE:
5384 case ESCAPE:
5385 case EXCEPT:
5386 case EXCEPTION:
5387 case EXCEPTIONS:
5388 case EXCLUSIVE:
5389 case EXECUTE:
5390 case EXISTS:
5391 case EXIT:
5392 case EXTERNAL:
5393 case EXTENDS:
5394 case EXTRACT:
5395 case FALSE:
5396 case FETCH:
5397 case FINAL:
5398 case FLOAT:
5399 case FOR:
5400 case FORALL:
5401 case FORCE:
5402 case FROM:
5403 case FUNCTION:
5404 case GLOBAL:
5405 case GOTO:
5406 case GROUP:
5407 case HASH:
5408 case HAVING:
5409 case HEAP:
5410 case HOUR:
5411 case IF:
5412 case IMMEDIATE:
5413 case IN:
5414 case INDEX:
5415 case INDICES:
5416 case INDEXTYPE:
5417 case INDICATOR:
5418 case INSERT:
5419 case INSTANTIABLE:
5420 case INTEGER:
5421 case INTERFACE:
5422 case INTERSECT:
5423 case INTERVAL:
5424 case INTO:
5425 case INVALIDATE:
5426 case IS:
5427 case ISOLATION:
5428 case JAVA:
5429 case LEVEL:
5430 case LIKE:
5431 case LIMIT:
5432 case LIMITED:
5433 case LOCK:
5434 case LONG:
5435 case LOOP:
5436 case MAP:
5437 case MAX:
5438 case MEMBER:
5439 case MERGE:
5440 case MIN:
5441 case MINUS:
5442 case MINUTE:
5443 case MLSLABEL:
5444 case MODIFY:
5445 case MOD:
5446 case MODE:
5447 case MONTH:
5448 case NATURAL:
5449 case NATURALN:
5450 case NEW:
5451 case NEXTVAL:
5452 case NO:
5453 case NOCOPY:
5454 case NONEDITIONABLE:
5455 case NOT:
5456 case NOWAIT:
5457 case NULL:
5458 case NULLIF:
5459 case NUMBER:
5460 case BFILE_BASE:
5461 case BLOB_BASE:
5462 case CLOB_BASE:
5463 case DATE_BASE:
5464 case NUMBER_BASE:
5465 case OBJECT:
5466 case OCIROWID:
5467 case OF:
5468 case OID:
5469 case ON:
5470 case OPAQUE:
5471 case OPEN:
5472 case OPERATOR:
5473 case OPTION:
5474 case OR:
5475 case ORDER:
5476 case ORGANIZATION:
5477 case OTHERS:
5478 case OUT:
5479 case OVERRIDING:
5480 case PACKAGE:
5481 case PARTITION:
5482 case PCTFREE:
5483 case PLS_INTEGER:
5484 case POSITIVE:
5485 case POSITIVEN:
5486 case PRAGMA:
5487 case PRESERVE:
5488 case PRIOR:
5489 case PROMPT:
5490 case PRIVATE:
5491 case PROCEDURE:
5492 case PUBLIC:
5493 case RAISE:
5494 case RANGE:
5495 case RAW:
5496 case REAL:
5497 case RECORD:
5498 case REF:
5499 case RELEASE:
5500 case RELIES_ON:
5501 case RENAME:
5502 case RESULT:
5503 case RETURN:
5504 case RETURNING:
5505 case REVERSE:
5506 case ROLLBACK:
5507 case ROW:
5508 case ROWS:
5509 case ROWID:
5510 case ROWNUM:
5511 case ROWTYPE:
5512 case SAVE:
5513 case SAVEPOINT:
5514 case SECOND:
5515 case SELECT:
5516 case SELF:
5517 case SEPARATE:
5518 case SET:
5519 case SHARE:
5520 case SMALLINT:
5521 case SPACE:
5522 case SQL:
5523 case SQLCODE:
5524 case SQLERRM:
5525 case START:
5526 case STATIC:
5527 case STDDEV:
5528 case SUBTYPE:
5529 case SUBSTITUTABLE:
5530 case SUCCESSFUL:
5531 case SUM:
5532 case SYNONYM:
5533 case SYSDATE:
5534 case SYS_REFCURSOR:
5535 case TABLE:
5536 case TEMPORARY:
5537 case THEN:
5538 case TIME:
5539 case TIMESTAMP:
5540 case TIMEZONE_REGION:
5541 case TIMEZONE_ABBR:
5542 case TIMEZONE_MINUTE:
5543 case TIMEZONE_HOUR:
5544 case TO:
5545 case TRANSACTION:
5546 case TRIGGER:
5547 case TRUE:
5548 case TYPE:
5549 case UI:
5550 case UNDER:
5551 case USING:
5552 case WHILE:
5553 case YES:
5554 case SHOW:
5555 case A:
5556 case UPDATE:
5557 case VARCHAR:
5558 case VARCHAR2:
5559 case DOUBLE:
5560 case DEC:
5561 case PRECISION:
5562 case INT:
5563 case NUMERIC:
5564 case SIGNTYPE:
5565 case NCHAR:
5566 case NVARCHAR2:
5567 case STRING:
5568 case UROWID:
5569 case VARRAY:
5570 case VARYING:
5571 case BFILE:
5572 case BLOB:
5573 case CLOB:
5574 case NCLOB:
5575 case YEAR:
5576 case LOCAL:
5577 case WITH:
5578 case ZONE:
5579 case CHARACTER:
5580 case AFTER:
5581 case BEFORE:
5582 case OLD:
5583 case PARENT:
5584 case CC_IF:
5585 case ANALYZE:
5586 case ASSOCIATE:
5587 case AUDIT:
5588 case COMPOUND:
5589 case DATABASE:
5590 case CALL:
5591 case DDL:
5592 case DISASSOCIATE:
5593 case EACH:
5594 case FOLLOWS:
5595 case LOGOFF:
5596 case LOGON:
5597 case NESTED:
5598 case NOAUDIT:
5599 case SCHEMA:
5600 case SERVERERROR:
5601 case SHUTDOWN:
5602 case STARTUP:
5603 case STATEMENT:
5604 case STATISTICS:
5605 case SUSPEND:
5606 case TRUNCATE:
5607 case WRAPPED:
5608 case LIBRARY:
5609 case NAME:
5610 case STRUCT:
5611 case CONTEXT:
5612 case PARAMETERS:
5613 case LENGTH:
5614 case TDO:
5615 case MAXLEN:
5616 case CHARSETID:
5617 case CHARSETFORM:
5618 case ACCEPT:
5619 case ACCESSIBLE:
5620 case COPY:
5621 case DEFINE:
5622 case DISCONNECT:
5623 case HOST:
5624 case PRINT:
5625 case QUIT:
5626 case REMARK:
5627 case UNDEFINE:
5628 case VARIABLE:
5629 case WHENEVER:
5630 case ATTACH:
5631 case CAST:
5632 case TREAT:
5633 case TRIM:
5634 case LEFT:
5635 case RIGHT:
5636 case BOTH:
5637 case EMPTY:
5638 case MULTISET:
5639 case SUBMULTISET:
5640 case LEADING:
5641 case TRAILING:
5642 case CHAR_CS:
5643 case NCHAR_CS:
5644 case DBTIMEZONE:
5645 case SESSIONTIMEZONE:
5646 case AUTHENTICATED:
5647 case LINK:
5648 case SHARED:
5649 case DIRECTORY:
5650 case USER:
5651 case IDENTIFIER:
5652 case QUOTED_LITERAL:
5653 case SQLDATA_CLASS:
5654 case CUSTOMDATUM_CLASS:
5655 case ORADATA_CLASS:
5656 case JAVA_INTERFACE_CLASS:
5657 DeclarativeSection();
5658 jj_consume_token(BEGIN);
5659 label_16:
5660 while (true) {
5661 switch (jj_nt.kind) {
5662 case 5:
5663 case 16:
5664 case 17:
5665 case 21:
5666 case REPLACE:
5667 case DEFINER:
5668 case CURRENT_USER:
5669 case LANGUAGE:
5670 case ADD:
5671 case AGGREGATE:
5672 case ARRAY:
5673 case AT:
5674 case ATTRIBUTE:
5675 case AUTHID:
5676 case BEGIN:
5677 case BODY:
5678 case BULK:
5679 case BYTE:
5680 case CASCADE:
5681 case CASE:
5682 case CLOSE:
5683 case COALESCE:
5684 case COLLECT:
5685 case COLUMN:
5686 case COMMENT:
5687 case COMMIT:
5688 case CONSTRUCTOR:
5689 case CONTINUE:
5690 case CONVERT:
5691 case CURRENT:
5692 case CURSOR:
5693 case DATA:
5694 case DATE:
5695 case DAY:
5696 case DECLARE:
5697 case DELETE:
5698 case DISABLE:
5699 case EDITIONABLE:
5700 case ELEMENT:
5701 case ENABLE:
5702 case ESCAPE:
5703 case EXCEPT:
5704 case EXCEPTIONS:
5705 case EXECUTE:
5706 case EXIT:
5707 case EXTERNAL:
5708 case EXTENDS:
5709 case EXTRACT:
5710 case FALSE:
5711 case FETCH:
5712 case FINAL:
5713 case FOR:
5714 case FORALL:
5715 case FORCE:
5716 case FUNCTION:
5717 case GLOBAL:
5718 case GOTO:
5719 case HASH:
5720 case HEAP:
5721 case HOUR:
5722 case IF:
5723 case IMMEDIATE:
5724 case INDICES:
5725 case INDEXTYPE:
5726 case INDICATOR:
5727 case INSERT:
5728 case INSTANTIABLE:
5729 case INTERVAL:
5730 case INVALIDATE:
5731 case ISOLATION:
5732 case JAVA:
5733 case LEVEL:
5734 case LIMIT:
5735 case LOCK:
5736 case LOOP:
5737 case MAP:
5738 case MAX:
5739 case MEMBER:
5740 case MERGE:
5741 case MIN:
5742 case MINUTE:
5743 case MLSLABEL:
5744 case MODIFY:
5745 case MOD:
5746 case MONTH:
5747 case NATURAL:
5748 case NEW:
5749 case NEW_DOT:
5750 case NO:
5751 case NONEDITIONABLE:
5752 case NOT:
5753 case NULL:
5754 case NULLIF:
5755 case OBJECT:
5756 case OID:
5757 case OPAQUE:
5758 case OPEN:
5759 case OPERATOR:
5760 case ORGANIZATION:
5761 case OTHERS:
5762 case OVERRIDING:
5763 case PACKAGE:
5764 case PARTITION:
5765 case PIPE:
5766 case PRESERVE:
5767 case PRIVATE:
5768 case PROCEDURE:
5769 case RAISE:
5770 case RANGE:
5771 case RAW:
5772 case REAL:
5773 case RECORD:
5774 case REF:
5775 case RELEASE:
5776 case RELIES_ON:
5777 case RENAME:
5778 case RESULT:
5779 case RETURN:
5780 case RETURNING:
5781 case REVERSE:
5782 case ROLLBACK:
5783 case ROW:
5784 case ROWS:
5785 case ROWID:
5786 case ROWNUM:
5787 case SAVE:
5788 case SAVEPOINT:
5789 case SECOND:
5790 case SELECT:
5791 case SELF:
5792 case SET:
5793 case SPACE:
5794 case SQL:
5795 case SQLCODE:
5796 case SQLERRM:
5797 case STATIC:
5798 case SUBTYPE:
5799 case SUBSTITUTABLE:
5800 case SUCCESSFUL:
5801 case SYSDATE:
5802 case SYS_REFCURSOR:
5803 case TEMPORARY:
5804 case TIME:
5805 case TIMESTAMP:
5806 case TIMEZONE_REGION:
5807 case TIMEZONE_ABBR:
5808 case TIMEZONE_MINUTE:
5809 case TIMEZONE_HOUR:
5810 case TRANSACTION:
5811 case TRUE:
5812 case TYPE:
5813 case UNDER:
5814 case USING:
5815 case WHILE:
5816 case YES:
5817 case SHOW:
5818 case A:
5819 case UPDATE:
5820 case DOUBLE:
5821 case DEC:
5822 case PRECISION:
5823 case INT:
5824 case NUMERIC:
5825 case NCHAR:
5826 case NVARCHAR2:
5827 case STRING:
5828 case UROWID:
5829 case VARRAY:
5830 case VARYING:
5831 case BFILE:
5832 case BLOB:
5833 case CLOB:
5834 case NCLOB:
5835 case YEAR:
5836 case LOCAL:
5837 case WITH:
5838 case ZONE:
5839 case CHARACTER:
5840 case AFTER:
5841 case BEFORE:
5842 case OLD:
5843 case PARENT:
5844 case CC_IF:
5845 case CC_ERROR:
5846 case ANALYZE:
5847 case ASSOCIATE:
5848 case AUDIT:
5849 case COMPOUND:
5850 case DATABASE:
5851 case CALL:
5852 case DDL:
5853 case DISASSOCIATE:
5854 case EACH:
5855 case FOLLOWS:
5856 case LOGOFF:
5857 case LOGON:
5858 case NESTED:
5859 case NOAUDIT:
5860 case SCHEMA:
5861 case SERVERERROR:
5862 case SHUTDOWN:
5863 case STARTUP:
5864 case STATEMENT:
5865 case STATISTICS:
5866 case SUSPEND:
5867 case TRUNCATE:
5868 case WRAPPED:
5869 case LIBRARY:
5870 case NAME:
5871 case STRUCT:
5872 case CONTEXT:
5873 case PARAMETERS:
5874 case LENGTH:
5875 case TDO:
5876 case MAXLEN:
5877 case CHARSETID:
5878 case CHARSETFORM:
5879 case ACCEPT:
5880 case ACCESSIBLE:
5881 case COPY:
5882 case DEFINE:
5883 case DISCONNECT:
5884 case HOST:
5885 case PRINT:
5886 case QUIT:
5887 case REMARK:
5888 case UNDEFINE:
5889 case VARIABLE:
5890 case WHENEVER:
5891 case ATTACH:
5892 case CAST:
5893 case TREAT:
5894 case TRIM:
5895 case LEFT:
5896 case RIGHT:
5897 case BOTH:
5898 case EMPTY:
5899 case MULTISET:
5900 case SUBMULTISET:
5901 case LEADING:
5902 case TRAILING:
5903 case CHAR_CS:
5904 case NCHAR_CS:
5905 case DBTIMEZONE:
5906 case SESSIONTIMEZONE:
5907 case AUTHENTICATED:
5908 case LINK:
5909 case SHARED:
5910 case DIRECTORY:
5911 case USER:
5912 case IDENTIFIER:
5913 case UNSIGNED_NUMERIC_LITERAL:
5914 case CHARACTER_LITERAL:
5915 case STRING_LITERAL:
5916 case QUOTED_LITERAL:
5917 ;
5918 break;
5919 default:
5920 jj_la1[64] = jj_gen;
5921 break label_16;
5922 }
5923 Statement();
5924 }
5925 switch (jj_nt.kind) {
5926 case EXCEPTION:
5927 ExceptionHandler();
5928 break;
5929 default:
5930 jj_la1[65] = jj_gen;
5931 ;
5932 }
5933 jj_consume_token(END);
5934 switch (jj_nt.kind) {
5935 case REPLACE:
5936 case DEFINER:
5937 case CURRENT_USER:
5938 case SERIALLY_REUSABLE:
5939 case RESTRICT_REFERENCES:
5940 case EXCEPTION_INIT:
5941 case AUTONOMOUS_TRANSACTION:
5942 case LANGUAGE:
5943 case ADD:
5944 case AGGREGATE:
5945 case ALL:
5946 case ALTER:
5947 case AND:
5948 case ANY:
5949 case ARRAY:
5950 case AS:
5951 case ASC:
5952 case AT:
5953 case ATTRIBUTE:
5954 case AUTHID:
5955 case AVG:
5956 case BETWEEN:
5957 case BINARY_INTEGER:
5958 case BODY:
5959 case BOOLEAN:
5960 case BULK:
5961 case BY:
5962 case BYTE:
5963 case CASCADE:
5964 case CASE:
5965 case CHAR:
5966 case CHAR_BASE:
5967 case CHECK:
5968 case CLOSE:
5969 case CLUSTER:
5970 case COALESCE:
5971 case COLLECT:
5972 case COLUMN:
5973 case COMMENT:
5974 case COMMIT:
5975 case COMPRESS:
5976 case CONNECT:
5977 case CONSTANT:
5978 case CONSTRUCTOR:
5979 case CONTINUE:
5980 case CONVERT:
5981 case CREATE:
5982 case CURRENT:
5983 case CURRVAL:
5984 case CURSOR:
5985 case DATA:
5986 case DATE:
5987 case DAY:
5988 case DECLARE:
5989 case DECIMAL:
5990 case _DEFAULT:
5991 case DELETE:
5992 case DESC:
5993 case DISABLE:
5994 case DISTINCT:
5995 case DO:
5996 case DROP:
5997 case EDITIONABLE:
5998 case ELEMENT:
5999 case ELSE:
6000 case ELSIF:
6001 case ENABLE:
6002 case ESCAPE:
6003 case EXCEPT:
6004 case EXCEPTION:
6005 case EXCEPTIONS:
6006 case EXCLUSIVE:
6007 case EXECUTE:
6008 case EXISTS:
6009 case EXIT:
6010 case EXTERNAL:
6011 case EXTENDS:
6012 case EXTRACT:
6013 case FALSE:
6014 case FETCH:
6015 case FINAL:
6016 case FLOAT:
6017 case FOR:
6018 case FORALL:
6019 case FORCE:
6020 case FROM:
6021 case FUNCTION:
6022 case GLOBAL:
6023 case GOTO:
6024 case GROUP:
6025 case HASH:
6026 case HAVING:
6027 case HEAP:
6028 case HOUR:
6029 case IF:
6030 case IMMEDIATE:
6031 case IN:
6032 case INDEX:
6033 case INDICES:
6034 case INDEXTYPE:
6035 case INDICATOR:
6036 case INSERT:
6037 case INSTANTIABLE:
6038 case INTEGER:
6039 case INTERFACE:
6040 case INTERSECT:
6041 case INTERVAL:
6042 case INTO:
6043 case INVALIDATE:
6044 case IS:
6045 case ISOLATION:
6046 case JAVA:
6047 case LEVEL:
6048 case LIKE:
6049 case LIMIT:
6050 case LIMITED:
6051 case LOCK:
6052 case LONG:
6053 case LOOP:
6054 case MAP:
6055 case MAX:
6056 case MEMBER:
6057 case MERGE:
6058 case MIN:
6059 case MINUS:
6060 case MINUTE:
6061 case MLSLABEL:
6062 case MODIFY:
6063 case MOD:
6064 case MODE:
6065 case MONTH:
6066 case NATURAL:
6067 case NATURALN:
6068 case NEW:
6069 case NEXTVAL:
6070 case NO:
6071 case NOCOPY:
6072 case NONEDITIONABLE:
6073 case NOT:
6074 case NOWAIT:
6075 case NULL:
6076 case NULLIF:
6077 case NUMBER:
6078 case BFILE_BASE:
6079 case BLOB_BASE:
6080 case CLOB_BASE:
6081 case DATE_BASE:
6082 case NUMBER_BASE:
6083 case OBJECT:
6084 case OCIROWID:
6085 case OF:
6086 case OID:
6087 case ON:
6088 case OPAQUE:
6089 case OPEN:
6090 case OPERATOR:
6091 case OPTION:
6092 case OR:
6093 case ORDER:
6094 case ORGANIZATION:
6095 case OTHERS:
6096 case OUT:
6097 case OVERRIDING:
6098 case PACKAGE:
6099 case PARTITION:
6100 case PCTFREE:
6101 case PLS_INTEGER:
6102 case POSITIVE:
6103 case POSITIVEN:
6104 case PRESERVE:
6105 case PRIOR:
6106 case PROMPT:
6107 case PRIVATE:
6108 case PROCEDURE:
6109 case PUBLIC:
6110 case RAISE:
6111 case RANGE:
6112 case RAW:
6113 case REAL:
6114 case RECORD:
6115 case REF:
6116 case RELEASE:
6117 case RELIES_ON:
6118 case RENAME:
6119 case RESULT:
6120 case RETURN:
6121 case RETURNING:
6122 case REVERSE:
6123 case ROLLBACK:
6124 case ROW:
6125 case ROWS:
6126 case ROWID:
6127 case ROWNUM:
6128 case ROWTYPE:
6129 case SAVE:
6130 case SAVEPOINT:
6131 case SECOND:
6132 case SELECT:
6133 case SELF:
6134 case SEPARATE:
6135 case SET:
6136 case SHARE:
6137 case SMALLINT:
6138 case SPACE:
6139 case SQL:
6140 case SQLCODE:
6141 case SQLERRM:
6142 case START:
6143 case STATIC:
6144 case STDDEV:
6145 case SUBTYPE:
6146 case SUBSTITUTABLE:
6147 case SUCCESSFUL:
6148 case SUM:
6149 case SYNONYM:
6150 case SYSDATE:
6151 case SYS_REFCURSOR:
6152 case TABLE:
6153 case TEMPORARY:
6154 case THEN:
6155 case TIME:
6156 case TIMESTAMP:
6157 case TIMEZONE_REGION:
6158 case TIMEZONE_ABBR:
6159 case TIMEZONE_MINUTE:
6160 case TIMEZONE_HOUR:
6161 case TO:
6162 case TRANSACTION:
6163 case TRIGGER:
6164 case TRUE:
6165 case TYPE:
6166 case UI:
6167 case UNDER:
6168 case USING:
6169 case WHILE:
6170 case YES:
6171 case SHOW:
6172 case A:
6173 case UPDATE:
6174 case VARCHAR:
6175 case VARCHAR2:
6176 case DOUBLE:
6177 case DEC:
6178 case PRECISION:
6179 case INT:
6180 case NUMERIC:
6181 case SIGNTYPE:
6182 case NCHAR:
6183 case NVARCHAR2:
6184 case STRING:
6185 case UROWID:
6186 case VARRAY:
6187 case VARYING:
6188 case BFILE:
6189 case BLOB:
6190 case CLOB:
6191 case NCLOB:
6192 case YEAR:
6193 case LOCAL:
6194 case WITH:
6195 case ZONE:
6196 case CHARACTER:
6197 case AFTER:
6198 case BEFORE:
6199 case OLD:
6200 case PARENT:
6201 case ANALYZE:
6202 case ASSOCIATE:
6203 case AUDIT:
6204 case COMPOUND:
6205 case DATABASE:
6206 case CALL:
6207 case DDL:
6208 case DISASSOCIATE:
6209 case EACH:
6210 case FOLLOWS:
6211 case LOGOFF:
6212 case LOGON:
6213 case NESTED:
6214 case NOAUDIT:
6215 case SCHEMA:
6216 case SERVERERROR:
6217 case SHUTDOWN:
6218 case STARTUP:
6219 case STATEMENT:
6220 case STATISTICS:
6221 case SUSPEND:
6222 case TRUNCATE:
6223 case WRAPPED:
6224 case LIBRARY:
6225 case NAME:
6226 case STRUCT:
6227 case CONTEXT:
6228 case PARAMETERS:
6229 case LENGTH:
6230 case TDO:
6231 case MAXLEN:
6232 case CHARSETID:
6233 case CHARSETFORM:
6234 case ACCEPT:
6235 case ACCESSIBLE:
6236 case COPY:
6237 case DEFINE:
6238 case DISCONNECT:
6239 case HOST:
6240 case PRINT:
6241 case QUIT:
6242 case REMARK:
6243 case UNDEFINE:
6244 case VARIABLE:
6245 case WHENEVER:
6246 case ATTACH:
6247 case CAST:
6248 case TREAT:
6249 case TRIM:
6250 case LEFT:
6251 case RIGHT:
6252 case BOTH:
6253 case EMPTY:
6254 case MULTISET:
6255 case SUBMULTISET:
6256 case LEADING:
6257 case TRAILING:
6258 case CHAR_CS:
6259 case NCHAR_CS:
6260 case DBTIMEZONE:
6261 case SESSIONTIMEZONE:
6262 case AUTHENTICATED:
6263 case LINK:
6264 case SHARED:
6265 case DIRECTORY:
6266 case USER:
6267 case IDENTIFIER:
6268 case QUOTED_LITERAL:
6269 case SQLDATA_CLASS:
6270 case CUSTOMDATUM_CLASS:
6271 case ORADATA_CLASS:
6272 case JAVA_INTERFACE_CLASS:
6273 ID();
6274 break;
6275 default:
6276 jj_la1[66] = jj_gen;
6277 ;
6278 }
6279 break;
6280 default:
6281 jj_la1[67] = jj_gen;
6282 jj_consume_token(-1);
6283 throw new ParseException();
6284 }
6285 }
6286 break;
6287 default:
6288 jj_la1[68] = jj_gen;
6289 ;
6290 }
6291 jj_consume_token(4);
6292 break;
6293 default:
6294 jj_la1[69] = jj_gen;
6295 jj_consume_token(-1);
6296 throw new ParseException();
6297 }
6298 jjtree.closeNodeScope(jjtn000, true);
6299 jjtc000 = false;
6300 {if (true) return jjtn000 ;}
6301 } catch (Throwable jjte000) {
6302 if (jjtc000) {
6303 jjtree.clearNodeScope(jjtn000);
6304 jjtc000 = false;
6305 } else {
6306 jjtree.popNode();
6307 }
6308 if (jjte000 instanceof RuntimeException) {
6309 {if (true) throw (RuntimeException)jjte000;}
6310 }
6311 if (jjte000 instanceof ParseException) {
6312 {if (true) throw (ParseException)jjte000;}
6313 }
6314 {if (true) throw (Error)jjte000;}
6315 } finally {
6316 if (jjtc000) {
6317 jjtree.closeNodeScope(jjtn000, true);
6318 }
6319 }
6320 throw new Error("Missing return statement in function");
6321 }
6322
6323 final public ASTObjectNameDeclaration ObjectNameDeclaration() throws ParseException {
6324
6325 ASTObjectNameDeclaration jjtn000 = new ASTObjectNameDeclaration(this, JJTOBJECTNAMEDECLARATION);
6326 boolean jjtc000 = true;
6327 jjtree.openNodeScope(jjtn000);PLSQLNode schemaName = null, objectName = null ;
6328 try {
6329 if (jj_2_22(2)) {
6330 schemaName = ID();
6331 jj_consume_token(3);
6332 } else {
6333 ;
6334 }
6335 objectName = ID();
6336 jjtn000.setImage( (null == schemaName) ? objectName.getImage() : (schemaName.getImage() + "." + objectName.getImage() ) ) ;
6337 jjtree.closeNodeScope(jjtn000, true);
6338 jjtc000 = false;
6339 {if (true) return jjtn000 ;}
6340 } catch (Throwable jjte000) {
6341 if (jjtc000) {
6342 jjtree.clearNodeScope(jjtn000);
6343 jjtc000 = false;
6344 } else {
6345 jjtree.popNode();
6346 }
6347 if (jjte000 instanceof RuntimeException) {
6348 {if (true) throw (RuntimeException)jjte000;}
6349 }
6350 if (jjte000 instanceof ParseException) {
6351 {if (true) throw (ParseException)jjte000;}
6352 }
6353 {if (true) throw (Error)jjte000;}
6354 } finally {
6355 if (jjtc000) {
6356 jjtree.closeNodeScope(jjtn000, true);
6357 }
6358 }
6359 throw new Error("Missing return statement in function");
6360 }
6361
6362 final public ASTFormalParameter FormalParameter() throws ParseException {
6363
6364 ASTFormalParameter jjtn000 = new ASTFormalParameter(this, JJTFORMALPARAMETER);
6365 boolean jjtc000 = true;
6366 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6367 try {
6368 simpleNode = ID();
6369 if (jj_2_25(2)) {
6370 if (jj_2_24(2)) {
6371 switch (jj_nt.kind) {
6372 case OUT:
6373 jj_consume_token(OUT);
6374 break;
6375 case IN:
6376 jj_consume_token(IN);
6377 jj_consume_token(OUT);
6378 break;
6379 default:
6380 jj_la1[70] = jj_gen;
6381 jj_consume_token(-1);
6382 throw new ParseException();
6383 }
6384 if (jj_2_23(2)) {
6385 jj_consume_token(NOCOPY);
6386 } else {
6387 ;
6388 }
6389 } else {
6390 switch (jj_nt.kind) {
6391 case IN:
6392 jj_consume_token(IN);
6393 break;
6394 default:
6395 jj_la1[71] = jj_gen;
6396 jj_consume_token(-1);
6397 throw new ParseException();
6398 }
6399 }
6400 } else {
6401 ;
6402 }
6403 switch (jj_nt.kind) {
6404 case 8:
6405 jj_consume_token(8);
6406 break;
6407 case REPLACE:
6408 case DEFINER:
6409 case CURRENT_USER:
6410 case LANGUAGE:
6411 case ADD:
6412 case AGGREGATE:
6413 case ARRAY:
6414 case AT:
6415 case ATTRIBUTE:
6416 case AUTHID:
6417 case BINARY_INTEGER:
6418 case BODY:
6419 case BOOLEAN:
6420 case BULK:
6421 case BYTE:
6422 case CASCADE:
6423 case CHAR:
6424 case CHAR_BASE:
6425 case CLOSE:
6426 case COALESCE:
6427 case COLLECT:
6428 case COLUMN:
6429 case COMMENT:
6430 case COMMIT:
6431 case CONSTRUCTOR:
6432 case CONTINUE:
6433 case CONVERT:
6434 case CURRENT:
6435 case CURSOR:
6436 case DATA:
6437 case DATE:
6438 case DAY:
6439 case DECIMAL:
6440 case DISABLE:
6441 case EDITIONABLE:
6442 case ELEMENT:
6443 case ENABLE:
6444 case ESCAPE:
6445 case EXCEPT:
6446 case EXCEPTIONS:
6447 case EXIT:
6448 case EXTERNAL:
6449 case EXTENDS:
6450 case EXTRACT:
6451 case FALSE:
6452 case FINAL:
6453 case FLOAT:
6454 case FORCE:
6455 case FUNCTION:
6456 case GLOBAL:
6457 case HASH:
6458 case HEAP:
6459 case HOUR:
6460 case IMMEDIATE:
6461 case INDICES:
6462 case INDEXTYPE:
6463 case INDICATOR:
6464 case INSTANTIABLE:
6465 case INTEGER:
6466 case INTERVAL:
6467 case INVALIDATE:
6468 case ISOLATION:
6469 case JAVA:
6470 case LEVEL:
6471 case LIMIT:
6472 case LONG:
6473 case LOOP:
6474 case MAP:
6475 case MAX:
6476 case MEMBER:
6477 case MERGE:
6478 case MIN:
6479 case MINUTE:
6480 case MLSLABEL:
6481 case MODIFY:
6482 case MOD:
6483 case MONTH:
6484 case NATURAL:
6485 case NATURALN:
6486 case NEW:
6487 case NO:
6488 case NONEDITIONABLE:
6489 case NULLIF:
6490 case NUMBER:
6491 case BFILE_BASE:
6492 case BLOB_BASE:
6493 case CLOB_BASE:
6494 case DATE_BASE:
6495 case NUMBER_BASE:
6496 case OBJECT:
6497 case OID:
6498 case OPAQUE:
6499 case OPEN:
6500 case OPERATOR:
6501 case ORGANIZATION:
6502 case OTHERS:
6503 case OVERRIDING:
6504 case PACKAGE:
6505 case PARTITION:
6506 case PLS_INTEGER:
6507 case POSITIVE:
6508 case POSITIVEN:
6509 case PRESERVE:
6510 case PRIVATE:
6511 case PROCEDURE:
6512 case RANGE:
6513 case RAW:
6514 case REAL:
6515 case RECORD:
6516 case REF:
6517 case RELEASE:
6518 case RELIES_ON:
6519 case RENAME:
6520 case RESULT:
6521 case RETURN:
6522 case RETURNING:
6523 case REVERSE:
6524 case ROLLBACK:
6525 case ROW:
6526 case ROWS:
6527 case ROWID:
6528 case ROWNUM:
6529 case SAVE:
6530 case SAVEPOINT:
6531 case SECOND:
6532 case SELF:
6533 case SET:
6534 case SMALLINT:
6535 case SPACE:
6536 case SQL:
6537 case SQLCODE:
6538 case SQLERRM:
6539 case STATIC:
6540 case SUBTYPE:
6541 case SUBSTITUTABLE:
6542 case SUCCESSFUL:
6543 case SYSDATE:
6544 case SYS_REFCURSOR:
6545 case TEMPORARY:
6546 case TIME:
6547 case TIMESTAMP:
6548 case TIMEZONE_REGION:
6549 case TIMEZONE_ABBR:
6550 case TIMEZONE_MINUTE:
6551 case TIMEZONE_HOUR:
6552 case TRANSACTION:
6553 case TRUE:
6554 case TYPE:
6555 case UNDER:
6556 case USING:
6557 case YES:
6558 case SHOW:
6559 case A:
6560 case VARCHAR:
6561 case VARCHAR2:
6562 case DOUBLE:
6563 case DEC:
6564 case PRECISION:
6565 case INT:
6566 case NUMERIC:
6567 case SIGNTYPE:
6568 case NCHAR:
6569 case NVARCHAR2:
6570 case STRING:
6571 case UROWID:
6572 case VARRAY:
6573 case VARYING:
6574 case BFILE:
6575 case BLOB:
6576 case CLOB:
6577 case NCLOB:
6578 case YEAR:
6579 case LOCAL:
6580 case ZONE:
6581 case CHARACTER:
6582 case AFTER:
6583 case BEFORE:
6584 case OLD:
6585 case PARENT:
6586 case CC_IF:
6587 case ANALYZE:
6588 case ASSOCIATE:
6589 case AUDIT:
6590 case COMPOUND:
6591 case DATABASE:
6592 case CALL:
6593 case DDL:
6594 case DISASSOCIATE:
6595 case EACH:
6596 case FOLLOWS:
6597 case LOGOFF:
6598 case LOGON:
6599 case NESTED:
6600 case NOAUDIT:
6601 case SCHEMA:
6602 case SERVERERROR:
6603 case SHUTDOWN:
6604 case STARTUP:
6605 case STATEMENT:
6606 case STATISTICS:
6607 case SUSPEND:
6608 case TRUNCATE:
6609 case WRAPPED:
6610 case LIBRARY:
6611 case NAME:
6612 case STRUCT:
6613 case CONTEXT:
6614 case PARAMETERS:
6615 case LENGTH:
6616 case TDO:
6617 case MAXLEN:
6618 case CHARSETID:
6619 case CHARSETFORM:
6620 case ACCEPT:
6621 case ACCESSIBLE:
6622 case COPY:
6623 case DEFINE:
6624 case DISCONNECT:
6625 case HOST:
6626 case PRINT:
6627 case QUIT:
6628 case REMARK:
6629 case UNDEFINE:
6630 case VARIABLE:
6631 case WHENEVER:
6632 case ATTACH:
6633 case CAST:
6634 case TREAT:
6635 case TRIM:
6636 case LEFT:
6637 case RIGHT:
6638 case BOTH:
6639 case EMPTY:
6640 case MULTISET:
6641 case SUBMULTISET:
6642 case LEADING:
6643 case TRAILING:
6644 case CHAR_CS:
6645 case NCHAR_CS:
6646 case DBTIMEZONE:
6647 case SESSIONTIMEZONE:
6648 case AUTHENTICATED:
6649 case LINK:
6650 case SHARED:
6651 case DIRECTORY:
6652 case USER:
6653 case IDENTIFIER:
6654 case QUOTED_LITERAL:
6655 Datatype();
6656 break;
6657 default:
6658 jj_la1[72] = jj_gen;
6659 jj_consume_token(-1);
6660 throw new ParseException();
6661 }
6662 switch (jj_nt.kind) {
6663 case 9:
6664 case _DEFAULT:
6665 switch (jj_nt.kind) {
6666 case 9:
6667 jj_consume_token(9);
6668 jj_consume_token(10);
6669 break;
6670 case _DEFAULT:
6671 jj_consume_token(_DEFAULT);
6672 break;
6673 default:
6674 jj_la1[73] = jj_gen;
6675 jj_consume_token(-1);
6676 throw new ParseException();
6677 }
6678 Expression();
6679 break;
6680 default:
6681 jj_la1[74] = jj_gen;
6682 ;
6683 }
6684 jjtree.closeNodeScope(jjtn000, true);
6685 jjtc000 = false;
6686 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
6687 } catch (Throwable jjte000) {
6688 if (jjtc000) {
6689 jjtree.clearNodeScope(jjtn000);
6690 jjtc000 = false;
6691 } else {
6692 jjtree.popNode();
6693 }
6694 if (jjte000 instanceof RuntimeException) {
6695 {if (true) throw (RuntimeException)jjte000;}
6696 }
6697 if (jjte000 instanceof ParseException) {
6698 {if (true) throw (ParseException)jjte000;}
6699 }
6700 {if (true) throw (Error)jjte000;}
6701 } finally {
6702 if (jjtc000) {
6703 jjtree.closeNodeScope(jjtn000, true);
6704 }
6705 }
6706 throw new Error("Missing return statement in function");
6707 }
6708
6709 final public ASTMethodDeclaration MethodDeclaration() throws ParseException {
6710
6711 ASTMethodDeclaration jjtn000 = new ASTMethodDeclaration(this, JJTMETHODDECLARATION);
6712 boolean jjtc000 = true;
6713 jjtree.openNodeScope(jjtn000);
6714 try {
6715 switch (jj_nt.kind) {
6716 case CREATE:
6717 case FUNCTION:
6718 case PROCEDURE:
6719 ProgramUnit();
6720 break;
6721 case CONSTRUCTOR:
6722 case FINAL:
6723 case INSTANTIABLE:
6724 case MAP:
6725 case MEMBER:
6726 case NOT:
6727 case ORDER:
6728 case OVERRIDING:
6729 case STATIC:
6730 TypeMethod();
6731 break;
6732 default:
6733 jj_la1[75] = jj_gen;
6734 jj_consume_token(-1);
6735 throw new ParseException();
6736 }
6737 jjtree.closeNodeScope(jjtn000, true);
6738 jjtc000 = false;
6739 {if (true) return jjtn000 ;}
6740 } catch (Throwable jjte000) {
6741 if (jjtc000) {
6742 jjtree.clearNodeScope(jjtn000);
6743 jjtc000 = false;
6744 } else {
6745 jjtree.popNode();
6746 }
6747 if (jjte000 instanceof RuntimeException) {
6748 {if (true) throw (RuntimeException)jjte000;}
6749 }
6750 if (jjte000 instanceof ParseException) {
6751 {if (true) throw (ParseException)jjte000;}
6752 }
6753 {if (true) throw (Error)jjte000;}
6754 } finally {
6755 if (jjtc000) {
6756 jjtree.closeNodeScope(jjtn000, true);
6757 }
6758 }
6759 throw new Error("Missing return statement in function");
6760 }
6761
6762 final public ASTMethodDeclarator MethodDeclarator() throws ParseException {
6763
6764 ASTMethodDeclarator jjtn000 = new ASTMethodDeclarator(this, JJTMETHODDECLARATOR);
6765 boolean jjtc000 = true;
6766 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6767 try {
6768 switch (jj_nt.kind) {
6769 case FUNCTION:
6770 jj_consume_token(FUNCTION);
6771 simpleNode = ObjectNameDeclaration();
6772 switch (jj_nt.kind) {
6773 case 5:
6774 FormalParameters();
6775 break;
6776 default:
6777 jj_la1[76] = jj_gen;
6778 ;
6779 }
6780 Token nextToken;
6781 nextToken = getToken(1);
6782 if (!nextToken.image.equalsIgnoreCase("WRAPPED")
6783 &&
6784 !nextToken.image.equalsIgnoreCase("RETURN")
6785 )
6786 {
6787 {if (true) throw new ParseException("FUNCTION must RETURN a value or must be WRAPPED : found \u005c""
6788 + nextToken.image
6789 + "\u005c" at line "+nextToken.beginLine
6790 + ", column "+nextToken.beginColumn
6791 );}
6792 }
6793 switch (jj_nt.kind) {
6794 case RETURN:
6795 jj_consume_token(RETURN);
6796 Datatype();
6797 break;
6798 default:
6799 jj_la1[77] = jj_gen;
6800 ;
6801 }
6802 break;
6803 case PROCEDURE:
6804 jj_consume_token(PROCEDURE);
6805 simpleNode = ObjectNameDeclaration();
6806 switch (jj_nt.kind) {
6807 case 5:
6808 FormalParameters();
6809 break;
6810 default:
6811 jj_la1[78] = jj_gen;
6812 ;
6813 }
6814 break;
6815 default:
6816 jj_la1[79] = jj_gen;
6817 jj_consume_token(-1);
6818 throw new ParseException();
6819 }
6820 jjtree.closeNodeScope(jjtn000, true);
6821 jjtc000 = false;
6822 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
6823 } catch (Throwable jjte000) {
6824 if (jjtc000) {
6825 jjtree.clearNodeScope(jjtn000);
6826 jjtc000 = false;
6827 } else {
6828 jjtree.popNode();
6829 }
6830 if (jjte000 instanceof RuntimeException) {
6831 {if (true) throw (RuntimeException)jjte000;}
6832 }
6833 if (jjte000 instanceof ParseException) {
6834 {if (true) throw (ParseException)jjte000;}
6835 }
6836 {if (true) throw (Error)jjte000;}
6837 } finally {
6838 if (jjtc000) {
6839 jjtree.closeNodeScope(jjtn000, true);
6840 }
6841 }
6842 throw new Error("Missing return statement in function");
6843 }
6844
6845 final public ASTFormalParameters FormalParameters() throws ParseException {
6846
6847 ASTFormalParameters jjtn000 = new ASTFormalParameters(this, JJTFORMALPARAMETERS);
6848 boolean jjtc000 = true;
6849 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
6850 StringBuilder sb = new StringBuilder();
6851 try {
6852 jj_consume_token(5);
6853 sb.append("(");
6854 switch (jj_nt.kind) {
6855 case REPLACE:
6856 case DEFINER:
6857 case CURRENT_USER:
6858 case SERIALLY_REUSABLE:
6859 case RESTRICT_REFERENCES:
6860 case EXCEPTION_INIT:
6861 case AUTONOMOUS_TRANSACTION:
6862 case LANGUAGE:
6863 case ADD:
6864 case AGGREGATE:
6865 case ALL:
6866 case ALTER:
6867 case AND:
6868 case ANY:
6869 case ARRAY:
6870 case AS:
6871 case ASC:
6872 case AT:
6873 case ATTRIBUTE:
6874 case AUTHID:
6875 case AVG:
6876 case BETWEEN:
6877 case BINARY_INTEGER:
6878 case BODY:
6879 case BOOLEAN:
6880 case BULK:
6881 case BY:
6882 case BYTE:
6883 case CASCADE:
6884 case CASE:
6885 case CHAR:
6886 case CHAR_BASE:
6887 case CHECK:
6888 case CLOSE:
6889 case CLUSTER:
6890 case COALESCE:
6891 case COLLECT:
6892 case COLUMN:
6893 case COMMENT:
6894 case COMMIT:
6895 case COMPRESS:
6896 case CONNECT:
6897 case CONSTANT:
6898 case CONSTRUCTOR:
6899 case CONTINUE:
6900 case CONVERT:
6901 case CREATE:
6902 case CURRENT:
6903 case CURRVAL:
6904 case CURSOR:
6905 case DATA:
6906 case DATE:
6907 case DAY:
6908 case DECLARE:
6909 case DECIMAL:
6910 case _DEFAULT:
6911 case DELETE:
6912 case DESC:
6913 case DISABLE:
6914 case DISTINCT:
6915 case DO:
6916 case DROP:
6917 case EDITIONABLE:
6918 case ELEMENT:
6919 case ELSE:
6920 case ELSIF:
6921 case ENABLE:
6922 case ESCAPE:
6923 case EXCEPT:
6924 case EXCEPTION:
6925 case EXCEPTIONS:
6926 case EXCLUSIVE:
6927 case EXECUTE:
6928 case EXISTS:
6929 case EXIT:
6930 case EXTERNAL:
6931 case EXTENDS:
6932 case EXTRACT:
6933 case FALSE:
6934 case FETCH:
6935 case FINAL:
6936 case FLOAT:
6937 case FOR:
6938 case FORALL:
6939 case FORCE:
6940 case FROM:
6941 case FUNCTION:
6942 case GLOBAL:
6943 case GOTO:
6944 case GROUP:
6945 case HASH:
6946 case HAVING:
6947 case HEAP:
6948 case HOUR:
6949 case IF:
6950 case IMMEDIATE:
6951 case IN:
6952 case INDEX:
6953 case INDICES:
6954 case INDEXTYPE:
6955 case INDICATOR:
6956 case INSERT:
6957 case INSTANTIABLE:
6958 case INTEGER:
6959 case INTERFACE:
6960 case INTERSECT:
6961 case INTERVAL:
6962 case INTO:
6963 case INVALIDATE:
6964 case IS:
6965 case ISOLATION:
6966 case JAVA:
6967 case LEVEL:
6968 case LIKE:
6969 case LIMIT:
6970 case LIMITED:
6971 case LOCK:
6972 case LONG:
6973 case LOOP:
6974 case MAP:
6975 case MAX:
6976 case MEMBER:
6977 case MERGE:
6978 case MIN:
6979 case MINUS:
6980 case MINUTE:
6981 case MLSLABEL:
6982 case MODIFY:
6983 case MOD:
6984 case MODE:
6985 case MONTH:
6986 case NATURAL:
6987 case NATURALN:
6988 case NEW:
6989 case NEXTVAL:
6990 case NO:
6991 case NOCOPY:
6992 case NONEDITIONABLE:
6993 case NOT:
6994 case NOWAIT:
6995 case NULL:
6996 case NULLIF:
6997 case NUMBER:
6998 case BFILE_BASE:
6999 case BLOB_BASE:
7000 case CLOB_BASE:
7001 case DATE_BASE:
7002 case NUMBER_BASE:
7003 case OBJECT:
7004 case OCIROWID:
7005 case OF:
7006 case OID:
7007 case ON:
7008 case OPAQUE:
7009 case OPEN:
7010 case OPERATOR:
7011 case OPTION:
7012 case OR:
7013 case ORDER:
7014 case ORGANIZATION:
7015 case OTHERS:
7016 case OUT:
7017 case OVERRIDING:
7018 case PACKAGE:
7019 case PARTITION:
7020 case PCTFREE:
7021 case PLS_INTEGER:
7022 case POSITIVE:
7023 case POSITIVEN:
7024 case PRESERVE:
7025 case PRIOR:
7026 case PROMPT:
7027 case PRIVATE:
7028 case PROCEDURE:
7029 case PUBLIC:
7030 case RAISE:
7031 case RANGE:
7032 case RAW:
7033 case REAL:
7034 case RECORD:
7035 case REF:
7036 case RELEASE:
7037 case RELIES_ON:
7038 case RENAME:
7039 case RESULT:
7040 case RETURN:
7041 case RETURNING:
7042 case REVERSE:
7043 case ROLLBACK:
7044 case ROW:
7045 case ROWS:
7046 case ROWID:
7047 case ROWNUM:
7048 case ROWTYPE:
7049 case SAVE:
7050 case SAVEPOINT:
7051 case SECOND:
7052 case SELECT:
7053 case SELF:
7054 case SEPARATE:
7055 case SET:
7056 case SHARE:
7057 case SMALLINT:
7058 case SPACE:
7059 case SQL:
7060 case SQLCODE:
7061 case SQLERRM:
7062 case START:
7063 case STATIC:
7064 case STDDEV:
7065 case SUBTYPE:
7066 case SUBSTITUTABLE:
7067 case SUCCESSFUL:
7068 case SUM:
7069 case SYNONYM:
7070 case SYSDATE:
7071 case SYS_REFCURSOR:
7072 case TABLE:
7073 case TEMPORARY:
7074 case THEN:
7075 case TIME:
7076 case TIMESTAMP:
7077 case TIMEZONE_REGION:
7078 case TIMEZONE_ABBR:
7079 case TIMEZONE_MINUTE:
7080 case TIMEZONE_HOUR:
7081 case TO:
7082 case TRANSACTION:
7083 case TRIGGER:
7084 case TRUE:
7085 case TYPE:
7086 case UI:
7087 case UNDER:
7088 case USING:
7089 case WHILE:
7090 case YES:
7091 case SHOW:
7092 case A:
7093 case UPDATE:
7094 case VARCHAR:
7095 case VARCHAR2:
7096 case DOUBLE:
7097 case DEC:
7098 case PRECISION:
7099 case INT:
7100 case NUMERIC:
7101 case SIGNTYPE:
7102 case NCHAR:
7103 case NVARCHAR2:
7104 case STRING:
7105 case UROWID:
7106 case VARRAY:
7107 case VARYING:
7108 case BFILE:
7109 case BLOB:
7110 case CLOB:
7111 case NCLOB:
7112 case YEAR:
7113 case LOCAL:
7114 case WITH:
7115 case ZONE:
7116 case CHARACTER:
7117 case AFTER:
7118 case BEFORE:
7119 case OLD:
7120 case PARENT:
7121 case ANALYZE:
7122 case ASSOCIATE:
7123 case AUDIT:
7124 case COMPOUND:
7125 case DATABASE:
7126 case CALL:
7127 case DDL:
7128 case DISASSOCIATE:
7129 case EACH:
7130 case FOLLOWS:
7131 case LOGOFF:
7132 case LOGON:
7133 case NESTED:
7134 case NOAUDIT:
7135 case SCHEMA:
7136 case SERVERERROR:
7137 case SHUTDOWN:
7138 case STARTUP:
7139 case STATEMENT:
7140 case STATISTICS:
7141 case SUSPEND:
7142 case TRUNCATE:
7143 case WRAPPED:
7144 case LIBRARY:
7145 case NAME:
7146 case STRUCT:
7147 case CONTEXT:
7148 case PARAMETERS:
7149 case LENGTH:
7150 case TDO:
7151 case MAXLEN:
7152 case CHARSETID:
7153 case CHARSETFORM:
7154 case ACCEPT:
7155 case ACCESSIBLE:
7156 case COPY:
7157 case DEFINE:
7158 case DISCONNECT:
7159 case HOST:
7160 case PRINT:
7161 case QUIT:
7162 case REMARK:
7163 case UNDEFINE:
7164 case VARIABLE:
7165 case WHENEVER:
7166 case ATTACH:
7167 case CAST:
7168 case TREAT:
7169 case TRIM:
7170 case LEFT:
7171 case RIGHT:
7172 case BOTH:
7173 case EMPTY:
7174 case MULTISET:
7175 case SUBMULTISET:
7176 case LEADING:
7177 case TRAILING:
7178 case CHAR_CS:
7179 case NCHAR_CS:
7180 case DBTIMEZONE:
7181 case SESSIONTIMEZONE:
7182 case AUTHENTICATED:
7183 case LINK:
7184 case SHARED:
7185 case DIRECTORY:
7186 case USER:
7187 case IDENTIFIER:
7188 case QUOTED_LITERAL:
7189 case SQLDATA_CLASS:
7190 case CUSTOMDATUM_CLASS:
7191 case ORADATA_CLASS:
7192 case JAVA_INTERFACE_CLASS:
7193 simpleNode = FormalParameter();
7194 sb.append(simpleNode.getImage());
7195 label_17:
7196 while (true) {
7197 switch (jj_nt.kind) {
7198 case 6:
7199 ;
7200 break;
7201 default:
7202 jj_la1[80] = jj_gen;
7203 break label_17;
7204 }
7205 jj_consume_token(6);
7206 simpleNode = FormalParameter();
7207 sb.append(","+simpleNode.getImage());
7208 }
7209 break;
7210 default:
7211 jj_la1[81] = jj_gen;
7212 ;
7213 }
7214 jj_consume_token(7);
7215 sb.append(")");
7216 jjtree.closeNodeScope(jjtn000, true);
7217 jjtc000 = false;
7218 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
7219 } catch (Throwable jjte000) {
7220 if (jjtc000) {
7221 jjtree.clearNodeScope(jjtn000);
7222 jjtc000 = false;
7223 } else {
7224 jjtree.popNode();
7225 }
7226 if (jjte000 instanceof RuntimeException) {
7227 {if (true) throw (RuntimeException)jjte000;}
7228 }
7229 if (jjte000 instanceof ParseException) {
7230 {if (true) throw (ParseException)jjte000;}
7231 }
7232 {if (true) throw (Error)jjte000;}
7233 } finally {
7234 if (jjtc000) {
7235 jjtree.closeNodeScope(jjtn000, true);
7236 }
7237 }
7238 throw new Error("Missing return statement in function");
7239 }
7240
7241 final public ASTVariableOrConstantDeclarator VariableOrConstantDeclarator() throws ParseException {
7242
7243 ASTVariableOrConstantDeclarator jjtn000 = new ASTVariableOrConstantDeclarator(this, JJTVARIABLEORCONSTANTDECLARATOR);
7244 boolean jjtc000 = true;
7245 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7246 StringBuilder sb = new StringBuilder();
7247 try {
7248 simpleNode = VariableOrConstantDeclaratorId();
7249 sb.append(simpleNode.getImage());
7250 if (jj_2_26(2)) {
7251 jj_consume_token(CONSTANT);
7252 sb.append(" " + token.image);
7253 } else {
7254 ;
7255 }
7256 simpleNode = Datatype();
7257 sb.append(" " + simpleNode.getImage());
7258 switch (jj_nt.kind) {
7259 case NOT:
7260 case NULL:
7261 switch (jj_nt.kind) {
7262 case NOT:
7263 jj_consume_token(NOT);
7264 sb.append(" " + token.image);
7265 break;
7266 default:
7267 jj_la1[82] = jj_gen;
7268 ;
7269 }
7270 jj_consume_token(NULL);
7271 sb.append(" " + token.image);
7272 break;
7273 default:
7274 jj_la1[83] = jj_gen;
7275 ;
7276 }
7277 switch (jj_nt.kind) {
7278 case 9:
7279 case _DEFAULT:
7280 switch (jj_nt.kind) {
7281 case 9:
7282 jj_consume_token(9);
7283 jj_consume_token(10);
7284 sb.append(" :=");
7285 break;
7286 case _DEFAULT:
7287 jj_consume_token(_DEFAULT);
7288 sb.append(" " + token.image);
7289 break;
7290 default:
7291 jj_la1[84] = jj_gen;
7292 jj_consume_token(-1);
7293 throw new ParseException();
7294 }
7295 simpleNode = VariableOrConstantInitializer();
7296 sb.append(" " + simpleNode.getImage());
7297 break;
7298 default:
7299 jj_la1[85] = jj_gen;
7300 ;
7301 }
7302 jjtree.closeNodeScope(jjtn000, true);
7303 jjtc000 = false;
7304 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
7305 } catch (Throwable jjte000) {
7306 if (jjtc000) {
7307 jjtree.clearNodeScope(jjtn000);
7308 jjtc000 = false;
7309 } else {
7310 jjtree.popNode();
7311 }
7312 if (jjte000 instanceof RuntimeException) {
7313 {if (true) throw (RuntimeException)jjte000;}
7314 }
7315 if (jjte000 instanceof ParseException) {
7316 {if (true) throw (ParseException)jjte000;}
7317 }
7318 {if (true) throw (Error)jjte000;}
7319 } finally {
7320 if (jjtc000) {
7321 jjtree.closeNodeScope(jjtn000, true);
7322 }
7323 }
7324 throw new Error("Missing return statement in function");
7325 }
7326
7327 final public ASTVariableOrConstantDeclaratorId VariableOrConstantDeclaratorId() throws ParseException {
7328
7329 ASTVariableOrConstantDeclaratorId jjtn000 = new ASTVariableOrConstantDeclaratorId(this, JJTVARIABLEORCONSTANTDECLARATORID);
7330 boolean jjtc000 = true;
7331 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7332 try {
7333 simpleNode = ID();
7334 jjtree.closeNodeScope(jjtn000, true);
7335 jjtc000 = false;
7336 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
7337 } catch (Throwable jjte000) {
7338 if (jjtc000) {
7339 jjtree.clearNodeScope(jjtn000);
7340 jjtc000 = false;
7341 } else {
7342 jjtree.popNode();
7343 }
7344 if (jjte000 instanceof RuntimeException) {
7345 {if (true) throw (RuntimeException)jjte000;}
7346 }
7347 if (jjte000 instanceof ParseException) {
7348 {if (true) throw (ParseException)jjte000;}
7349 }
7350 {if (true) throw (Error)jjte000;}
7351 } finally {
7352 if (jjtc000) {
7353 jjtree.closeNodeScope(jjtn000, true);
7354 }
7355 }
7356 throw new Error("Missing return statement in function");
7357 }
7358
7359 final public ASTVariableOrConstantInitializer VariableOrConstantInitializer() throws ParseException {
7360
7361 ASTVariableOrConstantInitializer jjtn000 = new ASTVariableOrConstantInitializer(this, JJTVARIABLEORCONSTANTINITIALIZER);
7362 boolean jjtc000 = true;
7363 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7364 try {
7365 simpleNode = Expression();
7366 jjtree.closeNodeScope(jjtn000, true);
7367 jjtc000 = false;
7368 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
7369 } catch (Throwable jjte000) {
7370 if (jjtc000) {
7371 jjtree.clearNodeScope(jjtn000);
7372 jjtc000 = false;
7373 } else {
7374 jjtree.popNode();
7375 }
7376 if (jjte000 instanceof RuntimeException) {
7377 {if (true) throw (RuntimeException)jjte000;}
7378 }
7379 if (jjte000 instanceof ParseException) {
7380 {if (true) throw (ParseException)jjte000;}
7381 }
7382 {if (true) throw (Error)jjte000;}
7383 } finally {
7384 if (jjtc000) {
7385 jjtree.closeNodeScope(jjtn000, true);
7386 }
7387 }
7388 throw new Error("Missing return statement in function");
7389 }
7390
7391 final public ASTDatatype Datatype() throws ParseException {
7392
7393 ASTDatatype jjtn000 = new ASTDatatype(this, JJTDATATYPE);
7394 boolean jjtc000 = true;
7395 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
7396 StringBuilder sb = new StringBuilder();
7397 try {
7398 switch (jj_nt.kind) {
7399 case CC_IF:
7400
7401 simpleNode = CompilationDataType();
7402 sb.append(simpleNode.getImage());
7403 break;
7404 default:
7405 jj_la1[89] = jj_gen;
7406 if (jj_2_28(2)) {
7407 simpleNode = ScalarDataTypeName();
7408 sb.append(simpleNode.getImage());
7409 } else {
7410 switch (jj_nt.kind) {
7411 case REPLACE:
7412 case DEFINER:
7413 case CURRENT_USER:
7414 case LANGUAGE:
7415 case ADD:
7416 case AGGREGATE:
7417 case ARRAY:
7418 case AT:
7419 case ATTRIBUTE:
7420 case AUTHID:
7421 case BODY:
7422 case BULK:
7423 case BYTE:
7424 case CASCADE:
7425 case CLOSE:
7426 case COALESCE:
7427 case COLLECT:
7428 case COLUMN:
7429 case COMMENT:
7430 case COMMIT:
7431 case CONSTRUCTOR:
7432 case CONTINUE:
7433 case CONVERT:
7434 case CURRENT:
7435 case CURSOR:
7436 case DATA:
7437 case DAY:
7438 case DISABLE:
7439 case EDITIONABLE:
7440 case ELEMENT:
7441 case ENABLE:
7442 case ESCAPE:
7443 case EXCEPT:
7444 case EXCEPTIONS:
7445 case EXIT:
7446 case EXTERNAL:
7447 case EXTENDS:
7448 case EXTRACT:
7449 case FALSE:
7450 case FINAL:
7451 case FORCE:
7452 case FUNCTION:
7453 case GLOBAL:
7454 case HASH:
7455 case HEAP:
7456 case HOUR:
7457 case IMMEDIATE:
7458 case INDICES:
7459 case INDEXTYPE:
7460 case INDICATOR:
7461 case INSTANTIABLE:
7462 case INTERVAL:
7463 case INVALIDATE:
7464 case ISOLATION:
7465 case JAVA:
7466 case LEVEL:
7467 case LIMIT:
7468 case LOOP:
7469 case MAP:
7470 case MAX:
7471 case MEMBER:
7472 case MERGE:
7473 case MIN:
7474 case MINUTE:
7475 case MLSLABEL:
7476 case MODIFY:
7477 case MOD:
7478 case MONTH:
7479 case NATURAL:
7480 case NEW:
7481 case NO:
7482 case NONEDITIONABLE:
7483 case NULLIF:
7484 case OBJECT:
7485 case OID:
7486 case OPAQUE:
7487 case OPEN:
7488 case OPERATOR:
7489 case ORGANIZATION:
7490 case OTHERS:
7491 case OVERRIDING:
7492 case PACKAGE:
7493 case PARTITION:
7494 case PRESERVE:
7495 case PRIVATE:
7496 case PROCEDURE:
7497 case RANGE:
7498 case RAW:
7499 case REAL:
7500 case RECORD:
7501 case REF:
7502 case RELEASE:
7503 case RELIES_ON:
7504 case RENAME:
7505 case RESULT:
7506 case RETURN:
7507 case RETURNING:
7508 case REVERSE:
7509 case ROLLBACK:
7510 case ROW:
7511 case ROWS:
7512 case ROWID:
7513 case ROWNUM:
7514 case SAVE:
7515 case SAVEPOINT:
7516 case SECOND:
7517 case SELF:
7518 case SET:
7519 case SPACE:
7520 case SQL:
7521 case SQLCODE:
7522 case SQLERRM:
7523 case STATIC:
7524 case SUBTYPE:
7525 case SUBSTITUTABLE:
7526 case SUCCESSFUL:
7527 case SYSDATE:
7528 case SYS_REFCURSOR:
7529 case TEMPORARY:
7530 case TIME:
7531 case TIMESTAMP:
7532 case TIMEZONE_REGION:
7533 case TIMEZONE_ABBR:
7534 case TIMEZONE_MINUTE:
7535 case TIMEZONE_HOUR:
7536 case TRANSACTION:
7537 case TRUE:
7538 case TYPE:
7539 case UNDER:
7540 case USING:
7541 case YES:
7542 case SHOW:
7543 case A:
7544 case DOUBLE:
7545 case DEC:
7546 case PRECISION:
7547 case INT:
7548 case NUMERIC:
7549 case NCHAR:
7550 case NVARCHAR2:
7551 case STRING:
7552 case UROWID:
7553 case VARRAY:
7554 case VARYING:
7555 case BFILE:
7556 case BLOB:
7557 case CLOB:
7558 case NCLOB:
7559 case YEAR:
7560 case LOCAL:
7561 case ZONE:
7562 case CHARACTER:
7563 case AFTER:
7564 case BEFORE:
7565 case OLD:
7566 case PARENT:
7567 case ANALYZE:
7568 case ASSOCIATE:
7569 case AUDIT:
7570 case COMPOUND:
7571 case DATABASE:
7572 case CALL:
7573 case DDL:
7574 case DISASSOCIATE:
7575 case EACH:
7576 case FOLLOWS:
7577 case LOGOFF:
7578 case LOGON:
7579 case NESTED:
7580 case NOAUDIT:
7581 case SCHEMA:
7582 case SERVERERROR:
7583 case SHUTDOWN:
7584 case STARTUP:
7585 case STATEMENT:
7586 case STATISTICS:
7587 case SUSPEND:
7588 case TRUNCATE:
7589 case WRAPPED:
7590 case LIBRARY:
7591 case NAME:
7592 case STRUCT:
7593 case CONTEXT:
7594 case PARAMETERS:
7595 case LENGTH:
7596 case TDO:
7597 case MAXLEN:
7598 case CHARSETID:
7599 case CHARSETFORM:
7600 case ACCEPT:
7601 case ACCESSIBLE:
7602 case COPY:
7603 case DEFINE:
7604 case DISCONNECT:
7605 case HOST:
7606 case PRINT:
7607 case QUIT:
7608 case REMARK:
7609 case UNDEFINE:
7610 case VARIABLE:
7611 case WHENEVER:
7612 case ATTACH:
7613 case CAST:
7614 case TREAT:
7615 case TRIM:
7616 case LEFT:
7617 case RIGHT:
7618 case BOTH:
7619 case EMPTY:
7620 case MULTISET:
7621 case SUBMULTISET:
7622 case LEADING:
7623 case TRAILING:
7624 case CHAR_CS:
7625 case NCHAR_CS:
7626 case DBTIMEZONE:
7627 case SESSIONTIMEZONE:
7628 case AUTHENTICATED:
7629 case LINK:
7630 case SHARED:
7631 case DIRECTORY:
7632 case USER:
7633 case IDENTIFIER:
7634 case QUOTED_LITERAL:
7635 if (jj_2_27(2)) {
7636 jj_consume_token(REF);
7637 sb.append(token.image);
7638 } else {
7639 ;
7640 }
7641 simpleNode = QualifiedName();
7642 sb.append(simpleNode.getImage());
7643 switch (jj_nt.kind) {
7644 case 2:
7645 jj_consume_token(2);
7646 simpleNode = QualifiedName();
7647 sb.append("@"+simpleNode.getImage());
7648 break;
7649 default:
7650 jj_la1[86] = jj_gen;
7651 ;
7652 }
7653 switch (jj_nt.kind) {
7654 case 11:
7655 jj_consume_token(11);
7656 switch (jj_nt.kind) {
7657 case TYPE:
7658 jj_consume_token(TYPE);
7659 break;
7660 case ROWTYPE:
7661 jj_consume_token(ROWTYPE);
7662 break;
7663 default:
7664 jj_la1[87] = jj_gen;
7665 jj_consume_token(-1);
7666 throw new ParseException();
7667 }
7668 sb.append("%"+token.image);
7669 break;
7670 default:
7671 jj_la1[88] = jj_gen;
7672 ;
7673 }
7674 break;
7675 default:
7676 jj_la1[90] = jj_gen;
7677 jj_consume_token(-1);
7678 throw new ParseException();
7679 }
7680 }
7681 }
7682 jjtree.closeNodeScope(jjtn000, true);
7683 jjtc000 = false;
7684 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7685 } catch (Throwable jjte000) {
7686 if (jjtc000) {
7687 jjtree.clearNodeScope(jjtn000);
7688 jjtc000 = false;
7689 } else {
7690 jjtree.popNode();
7691 }
7692 if (jjte000 instanceof RuntimeException) {
7693 {if (true) throw (RuntimeException)jjte000;}
7694 }
7695 if (jjte000 instanceof ParseException) {
7696 {if (true) throw (ParseException)jjte000;}
7697 }
7698 {if (true) throw (Error)jjte000;}
7699 } finally {
7700 if (jjtc000) {
7701 jjtree.closeNodeScope(jjtn000, true);
7702 }
7703 }
7704 throw new Error("Missing return statement in function");
7705 }
7706
7707 final public ASTCompilationDataType CompilationDataType() throws ParseException {
7708
7709 ASTCompilationDataType jjtn000 = new ASTCompilationDataType(this, JJTCOMPILATIONDATATYPE);
7710 boolean jjtc000 = true;
7711 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
7712 StringBuilder sb = new StringBuilder() ;
7713 try {
7714 jj_consume_token(CC_IF);
7715 sb.append(" "); sb.append(token.image) ;
7716 simpleNode = ConditionalOrExpression();
7717 sb.append(" "); sb.append(simpleNode.getImage());
7718 jj_consume_token(CC_THEN);
7719 sb.append(" "); sb.append(token.image);
7720 simpleNode = Datatype();
7721 sb.append(" "); sb.append(simpleNode.getImage());
7722 label_18:
7723 while (true) {
7724 switch (jj_nt.kind) {
7725 case CC_ELSIF:
7726 ;
7727 break;
7728 default:
7729 jj_la1[91] = jj_gen;
7730 break label_18;
7731 }
7732 jj_consume_token(CC_ELSIF);
7733 sb.append(" "); sb.append(token.image);
7734 simpleNode = ConditionalOrExpression();
7735 sb.append(" "); sb.append(simpleNode.getImage());
7736 jj_consume_token(CC_THEN);
7737 sb.append(" "); sb.append(token.image);
7738 simpleNode = Datatype();
7739 sb.append(" "); sb.append(simpleNode.getImage());
7740 }
7741 label_19:
7742 while (true) {
7743 switch (jj_nt.kind) {
7744 case CC_ELSE:
7745 ;
7746 break;
7747 default:
7748 jj_la1[92] = jj_gen;
7749 break label_19;
7750 }
7751 jj_consume_token(CC_ELSE);
7752 sb.append(" "); sb.append(token.image);
7753 simpleNode = Datatype();
7754 sb.append(" "); sb.append(simpleNode.getImage());
7755 }
7756 jj_consume_token(CC_END);
7757 sb.append(" "); sb.append(token.image);
7758 jjtree.closeNodeScope(jjtn000, true);
7759 jjtc000 = false;
7760 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7761 } catch (Throwable jjte000) {
7762 if (jjtc000) {
7763 jjtree.clearNodeScope(jjtn000);
7764 jjtc000 = false;
7765 } else {
7766 jjtree.popNode();
7767 }
7768 if (jjte000 instanceof RuntimeException) {
7769 {if (true) throw (RuntimeException)jjte000;}
7770 }
7771 if (jjte000 instanceof ParseException) {
7772 {if (true) throw (ParseException)jjte000;}
7773 }
7774 {if (true) throw (Error)jjte000;}
7775 } finally {
7776 if (jjtc000) {
7777 jjtree.closeNodeScope(jjtn000, true);
7778 }
7779 }
7780 throw new Error("Missing return statement in function");
7781 }
7782
7783 final public ASTCollectionTypeName CollectionTypeName() throws ParseException {
7784
7785 ASTCollectionTypeName jjtn000 = new ASTCollectionTypeName(this, JJTCOLLECTIONTYPENAME);
7786 boolean jjtc000 = true;
7787 jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null;
7788 StringBuilder sb = new StringBuilder();
7789 try {
7790 switch (jj_nt.kind) {
7791 case TABLE:
7792 jj_consume_token(TABLE);
7793 break;
7794 case VARRAY:
7795 jj_consume_token(VARRAY);
7796 break;
7797 case VARYING:
7798 jj_consume_token(VARYING);
7799 jj_consume_token(ARRAY);
7800 sb.append( "VARYING ARRAY") ;
7801 break;
7802 default:
7803 jj_la1[93] = jj_gen;
7804 jj_consume_token(-1);
7805 throw new ParseException();
7806 }
7807 if (sb.length() == 0) {
7808 sb.append(token.toString());
7809 }
7810 if (jj_2_29(2)) {
7811 jj_consume_token(5);
7812 size = NumericLiteral();
7813 sb.append( "(" + size);
7814 switch (jj_nt.kind) {
7815 case 6:
7816 jj_consume_token(6);
7817 precision = NumericLiteral();
7818 sb.append( "," + precision);
7819 break;
7820 default:
7821 jj_la1[94] = jj_gen;
7822 ;
7823 }
7824 switch (jj_nt.kind) {
7825 case CHAR:
7826 jj_consume_token(CHAR);
7827 sb.append( " CHAR") ;
7828 break;
7829 default:
7830 jj_la1[95] = jj_gen;
7831 ;
7832 }
7833 switch (jj_nt.kind) {
7834 case BYTE:
7835 jj_consume_token(BYTE);
7836 sb.append( " BYTE") ;
7837 break;
7838 default:
7839 jj_la1[96] = jj_gen;
7840 ;
7841 }
7842 jj_consume_token(7);
7843 sb.append( ")");
7844 } else {
7845 ;
7846 }
7847 jjtree.closeNodeScope(jjtn000, true);
7848 jjtc000 = false;
7849 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000;}
7850 } catch (Throwable jjte000) {
7851 if (jjtc000) {
7852 jjtree.clearNodeScope(jjtn000);
7853 jjtc000 = false;
7854 } else {
7855 jjtree.popNode();
7856 }
7857 if (jjte000 instanceof RuntimeException) {
7858 {if (true) throw (RuntimeException)jjte000;}
7859 }
7860 if (jjte000 instanceof ParseException) {
7861 {if (true) throw (ParseException)jjte000;}
7862 }
7863 {if (true) throw (Error)jjte000;}
7864 } finally {
7865 if (jjtc000) {
7866 jjtree.closeNodeScope(jjtn000, true);
7867 }
7868 }
7869 throw new Error("Missing return statement in function");
7870 }
7871
7872 final public ASTScalarDataTypeName ScalarDataTypeName() throws ParseException {
7873
7874 ASTScalarDataTypeName jjtn000 = new ASTScalarDataTypeName(this, JJTSCALARDATATYPENAME);
7875 boolean jjtc000 = true;
7876 jjtree.openNodeScope(jjtn000);PLSQLNode size=null, precision=null ;
7877 StringBuilder name = new StringBuilder();
7878 PLSQLNode characterSet = null;
7879 try {
7880 switch (jj_nt.kind) {
7881 case BFILE_BASE:
7882 jj_consume_token(BFILE_BASE);
7883 break;
7884 case BLOB_BASE:
7885 jj_consume_token(BLOB_BASE);
7886 break;
7887 case CHAR_BASE:
7888 jj_consume_token(CHAR_BASE);
7889 break;
7890 case CLOB_BASE:
7891 jj_consume_token(CLOB_BASE);
7892 break;
7893 case DATE_BASE:
7894 jj_consume_token(DATE_BASE);
7895 break;
7896 case NUMBER_BASE:
7897 jj_consume_token(NUMBER_BASE);
7898 break;
7899 case BINARY_INTEGER:
7900 jj_consume_token(BINARY_INTEGER);
7901 break;
7902 case DEC:
7903 jj_consume_token(DEC);
7904 break;
7905 case DECIMAL:
7906 jj_consume_token(DECIMAL);
7907 break;
7908 case DOUBLE:
7909 jj_consume_token(DOUBLE);
7910 jj_consume_token(PRECISION);
7911 name.append("DOUBLE PRECISION");
7912 break;
7913 case FLOAT:
7914 jj_consume_token(FLOAT);
7915 break;
7916 case INT:
7917 jj_consume_token(INT);
7918 break;
7919 case INTEGER:
7920 jj_consume_token(INTEGER);
7921 break;
7922 case NATURAL:
7923 jj_consume_token(NATURAL);
7924 break;
7925 case NATURALN:
7926 jj_consume_token(NATURALN);
7927 break;
7928 case NUMBER:
7929 jj_consume_token(NUMBER);
7930 break;
7931 case NUMERIC:
7932 jj_consume_token(NUMERIC);
7933 break;
7934 case PLS_INTEGER:
7935 jj_consume_token(PLS_INTEGER);
7936 break;
7937 case POSITIVE:
7938 jj_consume_token(POSITIVE);
7939 break;
7940 case POSITIVEN:
7941 jj_consume_token(POSITIVEN);
7942 break;
7943 case REAL:
7944 jj_consume_token(REAL);
7945 break;
7946 case SIGNTYPE:
7947 jj_consume_token(SIGNTYPE);
7948 break;
7949 case SMALLINT:
7950 jj_consume_token(SMALLINT);
7951 break;
7952 case CHAR:
7953 case LONG:
7954 case RAW:
7955 case ROWID:
7956 case VARCHAR:
7957 case VARCHAR2:
7958 case NCHAR:
7959 case NVARCHAR2:
7960 case STRING:
7961 case UROWID:
7962 case CLOB:
7963 case NCLOB:
7964 case CHARACTER:
7965 switch (jj_nt.kind) {
7966 case CHAR:
7967 jj_consume_token(CHAR);
7968 break;
7969 case CHARACTER:
7970 jj_consume_token(CHARACTER);
7971 break;
7972 default:
7973 jj_la1[97] = jj_gen;
7974 if (jj_2_30(2)) {
7975 jj_consume_token(LONG);
7976 jj_consume_token(RAW);
7977 name.append("LONG RAW");
7978 } else {
7979 switch (jj_nt.kind) {
7980 case LONG:
7981 jj_consume_token(LONG);
7982 break;
7983 case NCHAR:
7984 jj_consume_token(NCHAR);
7985 break;
7986 case NVARCHAR2:
7987 jj_consume_token(NVARCHAR2);
7988 break;
7989 case RAW:
7990 jj_consume_token(RAW);
7991 break;
7992 case ROWID:
7993 jj_consume_token(ROWID);
7994 break;
7995 case STRING:
7996 jj_consume_token(STRING);
7997 break;
7998 case UROWID:
7999 jj_consume_token(UROWID);
8000 break;
8001 case VARCHAR:
8002 jj_consume_token(VARCHAR);
8003 break;
8004 case VARCHAR2:
8005 jj_consume_token(VARCHAR2);
8006 break;
8007 case CLOB:
8008 jj_consume_token(CLOB);
8009 break;
8010 case NCLOB:
8011 jj_consume_token(NCLOB);
8012 break;
8013 default:
8014 jj_la1[98] = jj_gen;
8015 jj_consume_token(-1);
8016 throw new ParseException();
8017 }
8018 }
8019 }
8020 break;
8021 case BOOLEAN:
8022 jj_consume_token(BOOLEAN);
8023 break;
8024 case BFILE:
8025 jj_consume_token(BFILE);
8026 break;
8027 case BLOB:
8028 jj_consume_token(BLOB);
8029 break;
8030 case SYS_REFCURSOR:
8031 jj_consume_token(SYS_REFCURSOR);
8032 break;
8033 case REF:
8034 jj_consume_token(REF);
8035 jj_consume_token(CURSOR);
8036 name.append("REF CURSOR");
8037 break;
8038 case DATE:
8039 jj_consume_token(DATE);
8040 break;
8041 default:
8042 jj_la1[99] = jj_gen;
8043 if (jj_2_31(2)) {
8044 jj_consume_token(INTERVAL);
8045 jj_consume_token(YEAR);
8046 name.append("INTERVAL YEAR");
8047 } else if (jj_2_32(2)) {
8048 jj_consume_token(INTERVAL);
8049 jj_consume_token(DAY);
8050 name.append("INTERVAL DAY");
8051 } else {
8052 switch (jj_nt.kind) {
8053 case TIME:
8054 jj_consume_token(TIME);
8055 break;
8056 case TIMESTAMP:
8057 jj_consume_token(TIMESTAMP);
8058 break;
8059 case SELF:
8060 jj_consume_token(SELF);
8061 jj_consume_token(AS);
8062 jj_consume_token(RESULT);
8063 name.append("SELF AS RESULT");
8064 break;
8065 default:
8066 jj_la1[100] = jj_gen;
8067 jj_consume_token(-1);
8068 throw new ParseException();
8069 }
8070 }
8071 }
8072 if (name.length() == 0 ) {
8073 name.append(token.toString());
8074 }
8075 if (jj_2_33(2)) {
8076 jj_consume_token(5);
8077 size = NumericLiteral();
8078 name.append("("); name.append(size.getImage()) ;
8079 switch (jj_nt.kind) {
8080 case 6:
8081 jj_consume_token(6);
8082 precision = UnaryExpression(true);
8083 name.append(",") ; name.append(precision.getImage()) ;
8084 break;
8085 default:
8086 jj_la1[101] = jj_gen;
8087 ;
8088 }
8089 switch (jj_nt.kind) {
8090 case CHAR:
8091 jj_consume_token(CHAR);
8092 name.append(" CHAR") ;
8093 break;
8094 default:
8095 jj_la1[102] = jj_gen;
8096 ;
8097 }
8098 switch (jj_nt.kind) {
8099 case BYTE:
8100 jj_consume_token(BYTE);
8101 name.append(" BYTE") ;
8102 break;
8103 default:
8104 jj_la1[103] = jj_gen;
8105 ;
8106 }
8107 jj_consume_token(7);
8108 name.append( ")") ;
8109 } else {
8110 ;
8111 }
8112 switch (jj_nt.kind) {
8113 case TO:
8114 case WITH:
8115 case CHARACTER:
8116 switch (jj_nt.kind) {
8117 case CHARACTER:
8118 jj_consume_token(CHARACTER);
8119 jj_consume_token(SET);
8120 characterSet = Name();
8121 name.append( " CHARACTER SET ") ; name.append(characterSet.getImage()) ;
8122 break;
8123 default:
8124 jj_la1[104] = jj_gen;
8125 if (jj_2_35(4)) {
8126 jj_consume_token(WITH);
8127 jj_consume_token(LOCAL);
8128 jj_consume_token(TIME);
8129 jj_consume_token(ZONE);
8130 name.append(" WITH LOCAL TIME ZONE");
8131 } else if (jj_2_36(3)) {
8132 jj_consume_token(WITH);
8133 jj_consume_token(TIME);
8134 jj_consume_token(ZONE);
8135 name.append( " WITH TIME ZONE");
8136 } else if (jj_2_37(2)) {
8137 jj_consume_token(TO);
8138 jj_consume_token(MONTH);
8139 name.append( " TO MONTH");
8140 } else if (jj_2_38(2)) {
8141 jj_consume_token(TO);
8142 jj_consume_token(SECOND);
8143 name.append( " TO SECOND");
8144 if (jj_2_34(2)) {
8145 jj_consume_token(5);
8146 precision = NumericLiteral();
8147 name.append( "(" + precision) ;
8148 jj_consume_token(7);
8149 name.append( ")");
8150 } else {
8151 ;
8152 }
8153 } else {
8154 jj_consume_token(-1);
8155 throw new ParseException();
8156 }
8157 }
8158 break;
8159 default:
8160 jj_la1[105] = jj_gen;
8161 ;
8162 }
8163 jjtree.closeNodeScope(jjtn000, true);
8164 jjtc000 = false;
8165 jjtn000.setImage(name.toString()) ; {if (true) return jjtn000;}
8166 } catch (Throwable jjte000) {
8167 if (jjtc000) {
8168 jjtree.clearNodeScope(jjtn000);
8169 jjtc000 = false;
8170 } else {
8171 jjtree.popNode();
8172 }
8173 if (jjte000 instanceof RuntimeException) {
8174 {if (true) throw (RuntimeException)jjte000;}
8175 }
8176 if (jjte000 instanceof ParseException) {
8177 {if (true) throw (ParseException)jjte000;}
8178 }
8179 {if (true) throw (Error)jjte000;}
8180 } finally {
8181 if (jjtc000) {
8182 jjtree.closeNodeScope(jjtn000, true);
8183 }
8184 }
8185 throw new Error("Missing return statement in function");
8186 }
8187
8188 final public ASTDateTimeLiteral DateTimeLiteral() throws ParseException {
8189
8190 ASTDateTimeLiteral jjtn000 = new ASTDateTimeLiteral(this, JJTDATETIMELITERAL);
8191 boolean jjtc000 = true;
8192 jjtree.openNodeScope(jjtn000);Token t = null ;
8193 PLSQLNode simpleNode = null ;
8194 StringBuilder sb = new StringBuilder() ;
8195 try {
8196 switch (jj_nt.kind) {
8197 case INTERVAL:
8198 jj_consume_token(INTERVAL);
8199 break;
8200 case TIMESTAMP:
8201 jj_consume_token(TIMESTAMP);
8202 break;
8203 case DATE:
8204 jj_consume_token(DATE);
8205 break;
8206 default:
8207 jj_la1[106] = jj_gen;
8208 jj_consume_token(-1);
8209 throw new ParseException();
8210 }
8211 sb.append(token.image);
8212 switch (jj_nt.kind) {
8213 case CHARACTER_LITERAL:
8214 jj_consume_token(CHARACTER_LITERAL);
8215 sb.append(" "); sb.append(token.image);
8216 break;
8217 case STRING_LITERAL:
8218 simpleNode = StringLiteral();
8219 sb.append(" "); sb.append(simpleNode.getImage());
8220 break;
8221 default:
8222 jj_la1[107] = jj_gen;
8223 jj_consume_token(-1);
8224 throw new ParseException();
8225 }
8226 switch (jj_nt.kind) {
8227 case DAY:
8228 case HOUR:
8229 case MINUTE:
8230 case MONTH:
8231 case SECOND:
8232 case YEAR:
8233 switch (jj_nt.kind) {
8234 case YEAR:
8235 jj_consume_token(YEAR);
8236 break;
8237 case MONTH:
8238 jj_consume_token(MONTH);
8239 break;
8240 case DAY:
8241 jj_consume_token(DAY);
8242 break;
8243 case HOUR:
8244 jj_consume_token(HOUR);
8245 break;
8246 case MINUTE:
8247 jj_consume_token(MINUTE);
8248 break;
8249 case SECOND:
8250 jj_consume_token(SECOND);
8251 break;
8252 default:
8253 jj_la1[108] = jj_gen;
8254 jj_consume_token(-1);
8255 throw new ParseException();
8256 }
8257 break;
8258 default:
8259 jj_la1[109] = jj_gen;
8260 ;
8261 }
8262 if (null != t)
8263 {
8264 sb.append(" "); sb.append(token.image);
8265 t = null;
8266 }
8267 if (jj_2_39(2)) {
8268 jj_consume_token(5);
8269 simpleNode = NumericLiteral();
8270 sb.append("("); sb.append(simpleNode.getImage());
8271 jj_consume_token(7);
8272 sb.append("}");
8273 } else {
8274 ;
8275 }
8276 switch (jj_nt.kind) {
8277 case TO:
8278 case WITH:
8279 switch (jj_nt.kind) {
8280 case WITH:
8281 jj_consume_token(WITH);
8282 sb.append(" "); sb.append(token.toString()) ;
8283 switch (jj_nt.kind) {
8284 case LOCAL:
8285 jj_consume_token(LOCAL);
8286 sb.append(" "); sb.append(token.toString()) ;
8287 break;
8288 default:
8289 jj_la1[110] = jj_gen;
8290 ;
8291 }
8292 jj_consume_token(TIME);
8293 jj_consume_token(ZONE);
8294 sb.append(" "); sb.append("TIME ZONE") ;
8295 break;
8296 case TO:
8297 jj_consume_token(TO);
8298 sb.append(" "); sb.append(token.toString()) ;
8299 switch (jj_nt.kind) {
8300 case YEAR:
8301 jj_consume_token(YEAR);
8302 break;
8303 case MONTH:
8304 jj_consume_token(MONTH);
8305 break;
8306 case DAY:
8307 jj_consume_token(DAY);
8308 break;
8309 case HOUR:
8310 jj_consume_token(HOUR);
8311 break;
8312 case MINUTE:
8313 jj_consume_token(MINUTE);
8314 break;
8315 case SECOND:
8316 jj_consume_token(SECOND);
8317 break;
8318 default:
8319 jj_la1[111] = jj_gen;
8320 jj_consume_token(-1);
8321 throw new ParseException();
8322 }
8323 sb.append(token.image);
8324 if (jj_2_40(2)) {
8325 jj_consume_token(5);
8326 simpleNode = NumericLiteral();
8327 sb.append("("); sb.append(simpleNode.getImage());
8328 jj_consume_token(7);
8329 sb.append("}");
8330 } else {
8331 ;
8332 }
8333 break;
8334 default:
8335 jj_la1[112] = jj_gen;
8336 jj_consume_token(-1);
8337 throw new ParseException();
8338 }
8339 break;
8340 default:
8341 jj_la1[113] = jj_gen;
8342 ;
8343 }
8344 jjtree.closeNodeScope(jjtn000, true);
8345 jjtc000 = false;
8346 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
8347 } catch (Throwable jjte000) {
8348 if (jjtc000) {
8349 jjtree.clearNodeScope(jjtn000);
8350 jjtc000 = false;
8351 } else {
8352 jjtree.popNode();
8353 }
8354 if (jjte000 instanceof RuntimeException) {
8355 {if (true) throw (RuntimeException)jjte000;}
8356 }
8357 if (jjte000 instanceof ParseException) {
8358 {if (true) throw (ParseException)jjte000;}
8359 }
8360 {if (true) throw (Error)jjte000;}
8361 } finally {
8362 if (jjtc000) {
8363 jjtree.closeNodeScope(jjtn000, true);
8364 }
8365 }
8366 throw new Error("Missing return statement in function");
8367 }
8368
8369 final public ASTExceptionHandler ExceptionHandler() throws ParseException {
8370
8371 ASTExceptionHandler jjtn000 = new ASTExceptionHandler(this, JJTEXCEPTIONHANDLER);
8372 boolean jjtc000 = true;
8373 jjtree.openNodeScope(jjtn000);
8374 try {
8375 jj_consume_token(EXCEPTION);
8376 label_20:
8377 while (true) {
8378 if (jj_2_41(2)) {
8379 ;
8380 } else {
8381 break label_20;
8382 }
8383 jj_consume_token(WHEN);
8384 QualifiedName();
8385 label_21:
8386 while (true) {
8387 switch (jj_nt.kind) {
8388 case OR:
8389 ;
8390 break;
8391 default:
8392 jj_la1[114] = jj_gen;
8393 break label_21;
8394 }
8395 jj_consume_token(OR);
8396 QualifiedName();
8397 }
8398 jj_consume_token(THEN);
8399 label_22:
8400 while (true) {
8401 Statement();
8402 switch (jj_nt.kind) {
8403 case 5:
8404 case 16:
8405 case 17:
8406 case 21:
8407 case REPLACE:
8408 case DEFINER:
8409 case CURRENT_USER:
8410 case LANGUAGE:
8411 case ADD:
8412 case AGGREGATE:
8413 case ARRAY:
8414 case AT:
8415 case ATTRIBUTE:
8416 case AUTHID:
8417 case BEGIN:
8418 case BODY:
8419 case BULK:
8420 case BYTE:
8421 case CASCADE:
8422 case CASE:
8423 case CLOSE:
8424 case COALESCE:
8425 case COLLECT:
8426 case COLUMN:
8427 case COMMENT:
8428 case COMMIT:
8429 case CONSTRUCTOR:
8430 case CONTINUE:
8431 case CONVERT:
8432 case CURRENT:
8433 case CURSOR:
8434 case DATA:
8435 case DATE:
8436 case DAY:
8437 case DECLARE:
8438 case DELETE:
8439 case DISABLE:
8440 case EDITIONABLE:
8441 case ELEMENT:
8442 case ENABLE:
8443 case ESCAPE:
8444 case EXCEPT:
8445 case EXCEPTIONS:
8446 case EXECUTE:
8447 case EXIT:
8448 case EXTERNAL:
8449 case EXTENDS:
8450 case EXTRACT:
8451 case FALSE:
8452 case FETCH:
8453 case FINAL:
8454 case FOR:
8455 case FORALL:
8456 case FORCE:
8457 case FUNCTION:
8458 case GLOBAL:
8459 case GOTO:
8460 case HASH:
8461 case HEAP:
8462 case HOUR:
8463 case IF:
8464 case IMMEDIATE:
8465 case INDICES:
8466 case INDEXTYPE:
8467 case INDICATOR:
8468 case INSERT:
8469 case INSTANTIABLE:
8470 case INTERVAL:
8471 case INVALIDATE:
8472 case ISOLATION:
8473 case JAVA:
8474 case LEVEL:
8475 case LIMIT:
8476 case LOCK:
8477 case LOOP:
8478 case MAP:
8479 case MAX:
8480 case MEMBER:
8481 case MERGE:
8482 case MIN:
8483 case MINUTE:
8484 case MLSLABEL:
8485 case MODIFY:
8486 case MOD:
8487 case MONTH:
8488 case NATURAL:
8489 case NEW:
8490 case NEW_DOT:
8491 case NO:
8492 case NONEDITIONABLE:
8493 case NOT:
8494 case NULL:
8495 case NULLIF:
8496 case OBJECT:
8497 case OID:
8498 case OPAQUE:
8499 case OPEN:
8500 case OPERATOR:
8501 case ORGANIZATION:
8502 case OTHERS:
8503 case OVERRIDING:
8504 case PACKAGE:
8505 case PARTITION:
8506 case PIPE:
8507 case PRESERVE:
8508 case PRIVATE:
8509 case PROCEDURE:
8510 case RAISE:
8511 case RANGE:
8512 case RAW:
8513 case REAL:
8514 case RECORD:
8515 case REF:
8516 case RELEASE:
8517 case RELIES_ON:
8518 case RENAME:
8519 case RESULT:
8520 case RETURN:
8521 case RETURNING:
8522 case REVERSE:
8523 case ROLLBACK:
8524 case ROW:
8525 case ROWS:
8526 case ROWID:
8527 case ROWNUM:
8528 case SAVE:
8529 case SAVEPOINT:
8530 case SECOND:
8531 case SELECT:
8532 case SELF:
8533 case SET:
8534 case SPACE:
8535 case SQL:
8536 case SQLCODE:
8537 case SQLERRM:
8538 case STATIC:
8539 case SUBTYPE:
8540 case SUBSTITUTABLE:
8541 case SUCCESSFUL:
8542 case SYSDATE:
8543 case SYS_REFCURSOR:
8544 case TEMPORARY:
8545 case TIME:
8546 case TIMESTAMP:
8547 case TIMEZONE_REGION:
8548 case TIMEZONE_ABBR:
8549 case TIMEZONE_MINUTE:
8550 case TIMEZONE_HOUR:
8551 case TRANSACTION:
8552 case TRUE:
8553 case TYPE:
8554 case UNDER:
8555 case USING:
8556 case WHILE:
8557 case YES:
8558 case SHOW:
8559 case A:
8560 case UPDATE:
8561 case DOUBLE:
8562 case DEC:
8563 case PRECISION:
8564 case INT:
8565 case NUMERIC:
8566 case NCHAR:
8567 case NVARCHAR2:
8568 case STRING:
8569 case UROWID:
8570 case VARRAY:
8571 case VARYING:
8572 case BFILE:
8573 case BLOB:
8574 case CLOB:
8575 case NCLOB:
8576 case YEAR:
8577 case LOCAL:
8578 case WITH:
8579 case ZONE:
8580 case CHARACTER:
8581 case AFTER:
8582 case BEFORE:
8583 case OLD:
8584 case PARENT:
8585 case CC_IF:
8586 case CC_ERROR:
8587 case ANALYZE:
8588 case ASSOCIATE:
8589 case AUDIT:
8590 case COMPOUND:
8591 case DATABASE:
8592 case CALL:
8593 case DDL:
8594 case DISASSOCIATE:
8595 case EACH:
8596 case FOLLOWS:
8597 case LOGOFF:
8598 case LOGON:
8599 case NESTED:
8600 case NOAUDIT:
8601 case SCHEMA:
8602 case SERVERERROR:
8603 case SHUTDOWN:
8604 case STARTUP:
8605 case STATEMENT:
8606 case STATISTICS:
8607 case SUSPEND:
8608 case TRUNCATE:
8609 case WRAPPED:
8610 case LIBRARY:
8611 case NAME:
8612 case STRUCT:
8613 case CONTEXT:
8614 case PARAMETERS:
8615 case LENGTH:
8616 case TDO:
8617 case MAXLEN:
8618 case CHARSETID:
8619 case CHARSETFORM:
8620 case ACCEPT:
8621 case ACCESSIBLE:
8622 case COPY:
8623 case DEFINE:
8624 case DISCONNECT:
8625 case HOST:
8626 case PRINT:
8627 case QUIT:
8628 case REMARK:
8629 case UNDEFINE:
8630 case VARIABLE:
8631 case WHENEVER:
8632 case ATTACH:
8633 case CAST:
8634 case TREAT:
8635 case TRIM:
8636 case LEFT:
8637 case RIGHT:
8638 case BOTH:
8639 case EMPTY:
8640 case MULTISET:
8641 case SUBMULTISET:
8642 case LEADING:
8643 case TRAILING:
8644 case CHAR_CS:
8645 case NCHAR_CS:
8646 case DBTIMEZONE:
8647 case SESSIONTIMEZONE:
8648 case AUTHENTICATED:
8649 case LINK:
8650 case SHARED:
8651 case DIRECTORY:
8652 case USER:
8653 case IDENTIFIER:
8654 case UNSIGNED_NUMERIC_LITERAL:
8655 case CHARACTER_LITERAL:
8656 case STRING_LITERAL:
8657 case QUOTED_LITERAL:
8658 ;
8659 break;
8660 default:
8661 jj_la1[115] = jj_gen;
8662 break label_22;
8663 }
8664 }
8665 }
8666 switch (jj_nt.kind) {
8667 case WHEN:
8668 jj_consume_token(WHEN);
8669 jj_consume_token(OTHERS);
8670 jj_consume_token(THEN);
8671 label_23:
8672 while (true) {
8673 Statement();
8674 switch (jj_nt.kind) {
8675 case 5:
8676 case 16:
8677 case 17:
8678 case 21:
8679 case REPLACE:
8680 case DEFINER:
8681 case CURRENT_USER:
8682 case LANGUAGE:
8683 case ADD:
8684 case AGGREGATE:
8685 case ARRAY:
8686 case AT:
8687 case ATTRIBUTE:
8688 case AUTHID:
8689 case BEGIN:
8690 case BODY:
8691 case BULK:
8692 case BYTE:
8693 case CASCADE:
8694 case CASE:
8695 case CLOSE:
8696 case COALESCE:
8697 case COLLECT:
8698 case COLUMN:
8699 case COMMENT:
8700 case COMMIT:
8701 case CONSTRUCTOR:
8702 case CONTINUE:
8703 case CONVERT:
8704 case CURRENT:
8705 case CURSOR:
8706 case DATA:
8707 case DATE:
8708 case DAY:
8709 case DECLARE:
8710 case DELETE:
8711 case DISABLE:
8712 case EDITIONABLE:
8713 case ELEMENT:
8714 case ENABLE:
8715 case ESCAPE:
8716 case EXCEPT:
8717 case EXCEPTIONS:
8718 case EXECUTE:
8719 case EXIT:
8720 case EXTERNAL:
8721 case EXTENDS:
8722 case EXTRACT:
8723 case FALSE:
8724 case FETCH:
8725 case FINAL:
8726 case FOR:
8727 case FORALL:
8728 case FORCE:
8729 case FUNCTION:
8730 case GLOBAL:
8731 case GOTO:
8732 case HASH:
8733 case HEAP:
8734 case HOUR:
8735 case IF:
8736 case IMMEDIATE:
8737 case INDICES:
8738 case INDEXTYPE:
8739 case INDICATOR:
8740 case INSERT:
8741 case INSTANTIABLE:
8742 case INTERVAL:
8743 case INVALIDATE:
8744 case ISOLATION:
8745 case JAVA:
8746 case LEVEL:
8747 case LIMIT:
8748 case LOCK:
8749 case LOOP:
8750 case MAP:
8751 case MAX:
8752 case MEMBER:
8753 case MERGE:
8754 case MIN:
8755 case MINUTE:
8756 case MLSLABEL:
8757 case MODIFY:
8758 case MOD:
8759 case MONTH:
8760 case NATURAL:
8761 case NEW:
8762 case NEW_DOT:
8763 case NO:
8764 case NONEDITIONABLE:
8765 case NOT:
8766 case NULL:
8767 case NULLIF:
8768 case OBJECT:
8769 case OID:
8770 case OPAQUE:
8771 case OPEN:
8772 case OPERATOR:
8773 case ORGANIZATION:
8774 case OTHERS:
8775 case OVERRIDING:
8776 case PACKAGE:
8777 case PARTITION:
8778 case PIPE:
8779 case PRESERVE:
8780 case PRIVATE:
8781 case PROCEDURE:
8782 case RAISE:
8783 case RANGE:
8784 case RAW:
8785 case REAL:
8786 case RECORD:
8787 case REF:
8788 case RELEASE:
8789 case RELIES_ON:
8790 case RENAME:
8791 case RESULT:
8792 case RETURN:
8793 case RETURNING:
8794 case REVERSE:
8795 case ROLLBACK:
8796 case ROW:
8797 case ROWS:
8798 case ROWID:
8799 case ROWNUM:
8800 case SAVE:
8801 case SAVEPOINT:
8802 case SECOND:
8803 case SELECT:
8804 case SELF:
8805 case SET:
8806 case SPACE:
8807 case SQL:
8808 case SQLCODE:
8809 case SQLERRM:
8810 case STATIC:
8811 case SUBTYPE:
8812 case SUBSTITUTABLE:
8813 case SUCCESSFUL:
8814 case SYSDATE:
8815 case SYS_REFCURSOR:
8816 case TEMPORARY:
8817 case TIME:
8818 case TIMESTAMP:
8819 case TIMEZONE_REGION:
8820 case TIMEZONE_ABBR:
8821 case TIMEZONE_MINUTE:
8822 case TIMEZONE_HOUR:
8823 case TRANSACTION:
8824 case TRUE:
8825 case TYPE:
8826 case UNDER:
8827 case USING:
8828 case WHILE:
8829 case YES:
8830 case SHOW:
8831 case A:
8832 case UPDATE:
8833 case DOUBLE:
8834 case DEC:
8835 case PRECISION:
8836 case INT:
8837 case NUMERIC:
8838 case NCHAR:
8839 case NVARCHAR2:
8840 case STRING:
8841 case UROWID:
8842 case VARRAY:
8843 case VARYING:
8844 case BFILE:
8845 case BLOB:
8846 case CLOB:
8847 case NCLOB:
8848 case YEAR:
8849 case LOCAL:
8850 case WITH:
8851 case ZONE:
8852 case CHARACTER:
8853 case AFTER:
8854 case BEFORE:
8855 case OLD:
8856 case PARENT:
8857 case CC_IF:
8858 case CC_ERROR:
8859 case ANALYZE:
8860 case ASSOCIATE:
8861 case AUDIT:
8862 case COMPOUND:
8863 case DATABASE:
8864 case CALL:
8865 case DDL:
8866 case DISASSOCIATE:
8867 case EACH:
8868 case FOLLOWS:
8869 case LOGOFF:
8870 case LOGON:
8871 case NESTED:
8872 case NOAUDIT:
8873 case SCHEMA:
8874 case SERVERERROR:
8875 case SHUTDOWN:
8876 case STARTUP:
8877 case STATEMENT:
8878 case STATISTICS:
8879 case SUSPEND:
8880 case TRUNCATE:
8881 case WRAPPED:
8882 case LIBRARY:
8883 case NAME:
8884 case STRUCT:
8885 case CONTEXT:
8886 case PARAMETERS:
8887 case LENGTH:
8888 case TDO:
8889 case MAXLEN:
8890 case CHARSETID:
8891 case CHARSETFORM:
8892 case ACCEPT:
8893 case ACCESSIBLE:
8894 case COPY:
8895 case DEFINE:
8896 case DISCONNECT:
8897 case HOST:
8898 case PRINT:
8899 case QUIT:
8900 case REMARK:
8901 case UNDEFINE:
8902 case VARIABLE:
8903 case WHENEVER:
8904 case ATTACH:
8905 case CAST:
8906 case TREAT:
8907 case TRIM:
8908 case LEFT:
8909 case RIGHT:
8910 case BOTH:
8911 case EMPTY:
8912 case MULTISET:
8913 case SUBMULTISET:
8914 case LEADING:
8915 case TRAILING:
8916 case CHAR_CS:
8917 case NCHAR_CS:
8918 case DBTIMEZONE:
8919 case SESSIONTIMEZONE:
8920 case AUTHENTICATED:
8921 case LINK:
8922 case SHARED:
8923 case DIRECTORY:
8924 case USER:
8925 case IDENTIFIER:
8926 case UNSIGNED_NUMERIC_LITERAL:
8927 case CHARACTER_LITERAL:
8928 case STRING_LITERAL:
8929 case QUOTED_LITERAL:
8930 ;
8931 break;
8932 default:
8933 jj_la1[116] = jj_gen;
8934 break label_23;
8935 }
8936 }
8937 break;
8938 default:
8939 jj_la1[117] = jj_gen;
8940 ;
8941 }
8942 jjtree.closeNodeScope(jjtn000, true);
8943 jjtc000 = false;
8944 {if (true) return jjtn000 ;}
8945 } catch (Throwable jjte000) {
8946 if (jjtc000) {
8947 jjtree.clearNodeScope(jjtn000);
8948 jjtc000 = false;
8949 } else {
8950 jjtree.popNode();
8951 }
8952 if (jjte000 instanceof RuntimeException) {
8953 {if (true) throw (RuntimeException)jjte000;}
8954 }
8955 if (jjte000 instanceof ParseException) {
8956 {if (true) throw (ParseException)jjte000;}
8957 }
8958 {if (true) throw (Error)jjte000;}
8959 } finally {
8960 if (jjtc000) {
8961 jjtree.closeNodeScope(jjtn000, true);
8962 }
8963 }
8964 throw new Error("Missing return statement in function");
8965 }
8966
8967 final public void Skip2NextTerminator(String initiator,String terminator) throws ParseException {
8968
8969 ASTSkip2NextTerminator jjtn000 = new ASTSkip2NextTerminator(this, JJTSKIP2NEXTTERMINATOR);
8970 boolean jjtc000 = true;
8971 jjtree.openNodeScope(jjtn000);Token t = getToken(1);
8972 int count = (initiator == null) ? 0 : 1;
8973 if(t.image.equals(initiator)) count++;
8974 while (count > 0 || !t.image.equals(terminator))
8975 {
8976 t = getNextToken();
8977 t = getToken(1);
8978 if(t.image.equals(initiator)) count++;
8979 if(t.image.equals(terminator)) count--;
8980 }
8981 try {
8982 jjtree.closeNodeScope(jjtn000, true);
8983 jjtc000 = false;
8984 {if (true) return;}
8985 } finally {
8986 if (jjtc000) {
8987 jjtree.closeNodeScope(jjtn000, true);
8988 }
8989 }
8990 }
8991
8992
8993
8994
8995 final public void Skip2NextOccurrence(String target) throws ParseException {
8996
8997 ASTSkip2NextOccurrence jjtn000 = new ASTSkip2NextOccurrence(this, JJTSKIP2NEXTOCCURRENCE);
8998 boolean jjtc000 = true;
8999 jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9000 while (!nextToken.image.equals(target)
9001 && (null == nextToken.specialToken || !nextToken.specialToken.image.equals(target) )
9002 && nextToken.kind!=EOF
9003 )
9004 {
9005 nextToken = getNextToken();
9006 nextToken = getToken(1);
9007 }
9008 try {
9009 jjtree.closeNodeScope(jjtn000, true);
9010 jjtc000 = false;
9011 {if (true) return;}
9012 } finally {
9013 if (jjtc000) {
9014 jjtree.closeNodeScope(jjtn000, true);
9015 }
9016 }
9017 }
9018
9019
9020
9021
9022 final public void SkipPastNextOccurrence(String target) throws ParseException {
9023
9024 ASTSkipPastNextOccurrence jjtn000 = new ASTSkipPastNextOccurrence(this, JJTSKIPPASTNEXTOCCURRENCE);
9025 boolean jjtc000 = true;
9026 jjtree.openNodeScope(jjtn000);Token t = null;
9027 Skip2NextOccurrence(target) ;
9028 t = getNextToken();
9029 try {
9030 jjtree.closeNodeScope(jjtn000, true);
9031 jjtc000 = false;
9032 {if (true) return;}
9033 } finally {
9034 if (jjtc000) {
9035 jjtree.closeNodeScope(jjtn000, true);
9036 }
9037 }
9038 }
9039
9040
9041
9042
9043 final public void Skip2NextTokenOccurrence(int target) throws ParseException {
9044
9045 ASTSkip2NextTokenOccurrence jjtn000 = new ASTSkip2NextTokenOccurrence(this, JJTSKIP2NEXTTOKENOCCURRENCE);
9046 boolean jjtc000 = true;
9047 jjtree.openNodeScope(jjtn000);Token nextToken = getToken(1);
9048 Token specToken = null ;
9049 while (nextToken.kind!=target
9050 && (null == nextToken.specialToken || nextToken.specialToken.kind!=target )
9051 && nextToken.kind!=EOF
9052 )
9053 {
9054
9055
9056
9057
9058
9059
9060
9061
9062
9063
9064
9065
9066
9067
9068 specToken = nextToken.specialToken;
9069 if (null!= specToken)
9070 {
9071
9072 while (specToken != null && specToken.kind != target)
9073 {
9074 specToken = specToken.specialToken;
9075 }
9076
9077
9078 if (null != specToken && specToken.kind == target)
9079 {
9080 break;
9081 }
9082 }
9083
9084 nextToken = getNextToken();
9085 nextToken = getToken(1);
9086 }
9087 try {
9088 jjtree.closeNodeScope(jjtn000, true);
9089 jjtc000 = false;
9090 {if (true) return;}
9091 } finally {
9092 if (jjtc000) {
9093 jjtree.closeNodeScope(jjtn000, true);
9094 }
9095 }
9096 }
9097
9098
9099
9100
9101 final public void SkipPastNextTokenOccurrence(int target) throws ParseException {
9102
9103 ASTSkipPastNextTokenOccurrence jjtn000 = new ASTSkipPastNextTokenOccurrence(this, JJTSKIPPASTNEXTTOKENOCCURRENCE);
9104 boolean jjtc000 = true;
9105 jjtree.openNodeScope(jjtn000);Token t = null;
9106 Skip2NextTokenOccurrence(target) ;
9107 t = getNextToken();
9108 try {
9109 jjtree.closeNodeScope(jjtn000, true);
9110 jjtc000 = false;
9111 {if (true) return;}
9112 } finally {
9113 if (jjtc000) {
9114 jjtree.closeNodeScope(jjtn000, true);
9115 }
9116 }
9117 }
9118
9119
9120
9121
9122 final public ASTRead2NextOccurrence Read2NextOccurrence(String target) throws ParseException {
9123
9124 ASTRead2NextOccurrence jjtn000 = new ASTRead2NextOccurrence(this, JJTREAD2NEXTOCCURRENCE);
9125 boolean jjtc000 = true;
9126 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9127 Token nextToken = getToken(1);
9128 while (!nextToken.image.equals(target)
9129 && nextToken.kind!=EOF
9130 )
9131 {
9132 nextToken = getNextToken();
9133 sb.append(nextToken.image);
9134 nextToken = getToken(1);
9135 }
9136 try {
9137 jjtree.closeNodeScope(jjtn000, true);
9138 jjtc000 = false;
9139 jjtn000.setImage(sb.toString()) ; jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9140 } finally {
9141 if (jjtc000) {
9142 jjtree.closeNodeScope(jjtn000, true);
9143 }
9144 }
9145 throw new Error("Missing return statement in function");
9146 }
9147
9148
9149
9150
9151 final public ASTReadPastNextOccurrence ReadPastNextOccurrence(String target) throws ParseException {
9152
9153 ASTReadPastNextOccurrence jjtn000 = new ASTReadPastNextOccurrence(this, JJTREADPASTNEXTOCCURRENCE);
9154 boolean jjtc000 = true;
9155 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
9156 Token t = null;
9157 sb.append(Read2NextOccurrence(target)) ;
9158 t = getNextToken();
9159 sb.append(t.image);
9160 try {
9161 jjtree.closeNodeScope(jjtn000, true);
9162 jjtc000 = false;
9163 jjtn000.setImage(sb.toString()) ; jjtn000.value = sb.toString(); {if (true) return jjtn000 ;}
9164 } finally {
9165 if (jjtc000) {
9166 jjtree.closeNodeScope(jjtn000, true);
9167 }
9168 }
9169 throw new Error("Missing return statement in function");
9170 }
9171
9172
9173
9174
9175 final public ASTSqlStatement SqlStatement(String initiator, String terminator) throws ParseException {
9176
9177 ASTSqlStatement jjtn000 = new ASTSqlStatement(this, JJTSQLSTATEMENT);
9178 boolean jjtc000 = true;
9179 jjtree.openNodeScope(jjtn000);
9180 try {
9181 switch (jj_nt.kind) {
9182 case SELECT:
9183 jj_consume_token(SELECT);
9184 break;
9185 case UPDATE:
9186 jj_consume_token(UPDATE);
9187 break;
9188 case INSERT:
9189 jj_consume_token(INSERT);
9190 break;
9191 case DELETE:
9192 jj_consume_token(DELETE);
9193 break;
9194 case COMMIT:
9195 jj_consume_token(COMMIT);
9196 break;
9197 case ROLLBACK:
9198 jj_consume_token(ROLLBACK);
9199 break;
9200 case SAVEPOINT:
9201 jj_consume_token(SAVEPOINT);
9202 break;
9203 case EXECUTE:
9204 jj_consume_token(EXECUTE);
9205 break;
9206 case SET:
9207 jj_consume_token(SET);
9208 jj_consume_token(TRANSACTION);
9209 break;
9210 case LOCK:
9211 jj_consume_token(LOCK);
9212 jj_consume_token(TABLE);
9213 break;
9214 case MERGE:
9215 jj_consume_token(MERGE);
9216 break;
9217 case WITH:
9218 jj_consume_token(WITH);
9219 break;
9220 default:
9221 jj_la1[118] = jj_gen;
9222 jj_consume_token(-1);
9223 throw new ParseException();
9224 }
9225 Skip2NextTerminator(initiator,terminator);
9226 jjtree.closeNodeScope(jjtn000, true);
9227 jjtc000 = false;
9228 {if (true) return jjtn000 ;}
9229 } catch (Throwable jjte000) {
9230 if (jjtc000) {
9231 jjtree.clearNodeScope(jjtn000);
9232 jjtc000 = false;
9233 } else {
9234 jjtree.popNode();
9235 }
9236 if (jjte000 instanceof RuntimeException) {
9237 {if (true) throw (RuntimeException)jjte000;}
9238 }
9239 if (jjte000 instanceof ParseException) {
9240 {if (true) throw (ParseException)jjte000;}
9241 }
9242 {if (true) throw (Error)jjte000;}
9243 } finally {
9244 if (jjtc000) {
9245 jjtree.closeNodeScope(jjtn000, true);
9246 }
9247 }
9248 throw new Error("Missing return statement in function");
9249 }
9250
9251
9252
9253
9254
9255
9256
9257
9258
9259
9260
9261
9262
9263
9264
9265
9266
9267
9268
9269
9270
9271
9272
9273
9274
9275
9276
9277
9278
9279
9280
9281
9282
9283
9284
9285
9286
9287 final public void WrappedObject() throws ParseException {
9288
9289 ASTWrappedObject jjtn000 = new ASTWrappedObject(this, JJTWRAPPEDOBJECT);
9290 boolean jjtc000 = true;
9291 jjtree.openNodeScope(jjtn000);
9292 try {
9293 jj_consume_token(WRAPPED);
9294 jjtree.closeNodeScope(jjtn000, true);
9295 jjtc000 = false;
9296 Token nextToken;
9297
9298 nextToken = getToken(1);
9299 while (
9300 null != nextToken && nextToken.kind!=EOF
9301 )
9302 {
9303 nextToken = getNextToken();
9304
9305
9306 nextToken = getToken(1);
9307 }
9308 {if (true) return;}
9309 } finally {
9310 if (jjtc000) {
9311 jjtree.closeNodeScope(jjtn000, true);
9312 }
9313 }
9314 }
9315
9316
9317
9318
9319
9320
9321
9322
9323 final public ASTUnlabelledStatement UnlabelledStatement() throws ParseException {
9324
9325 ASTUnlabelledStatement jjtn000 = new ASTUnlabelledStatement(this, JJTUNLABELLEDSTATEMENT);
9326 boolean jjtc000 = true;
9327 jjtree.openNodeScope(jjtn000);
9328 try {
9329 if (jj_2_42(2147483647)) {
9330 SqlStatement(null,";");
9331 switch (jj_nt.kind) {
9332 case 4:
9333 jj_consume_token(4);
9334 break;
9335 default:
9336 jj_la1[119] = jj_gen;
9337 ;
9338 }
9339 } else if (jj_2_43(3)) {
9340 ContinueStatement();
9341 jj_consume_token(4);
9342 } else {
9343 switch (jj_nt.kind) {
9344 case CASE:
9345 CaseStatement();
9346 jj_consume_token(4);
9347 break;
9348 case IF:
9349 IfStatement();
9350 jj_consume_token(4);
9351 break;
9352 case FOR:
9353 ForStatement();
9354 jj_consume_token(4);
9355 break;
9356 case FORALL:
9357 ForAllStatement();
9358 jj_consume_token(4);
9359 break;
9360 case LOOP:
9361 LoopStatement();
9362 jj_consume_token(4);
9363 break;
9364 case WHILE:
9365 WhileStatement();
9366 jj_consume_token(4);
9367 break;
9368 case GOTO:
9369 GotoStatement();
9370 jj_consume_token(4);
9371 break;
9372 case RETURN:
9373 ReturnStatement();
9374 jj_consume_token(4);
9375 break;
9376 case EXIT:
9377 ExitStatement();
9378 jj_consume_token(4);
9379 break;
9380 case RAISE:
9381 RaiseStatement();
9382 jj_consume_token(4);
9383 break;
9384 case CLOSE:
9385 CloseStatement();
9386 jj_consume_token(4);
9387 break;
9388 case OPEN:
9389 OpenStatement();
9390 jj_consume_token(4);
9391 break;
9392 case FETCH:
9393 FetchStatement();
9394 jj_consume_token(4);
9395 break;
9396 case BEGIN:
9397 case DECLARE:
9398 Block();
9399 jj_consume_token(4);
9400 break;
9401 case EXECUTE:
9402 EmbeddedSqlStatement();
9403 jj_consume_token(4);
9404 break;
9405 case PIPE:
9406 PipelineStatement();
9407 jj_consume_token(4);
9408 break;
9409 case CC_IF:
9410 case CC_ERROR:
9411 ConditionalCompilationStatement();
9412 break;
9413 case 5:
9414 case 16:
9415 case 17:
9416 case REPLACE:
9417 case DEFINER:
9418 case CURRENT_USER:
9419 case LANGUAGE:
9420 case ADD:
9421 case AGGREGATE:
9422 case ARRAY:
9423 case AT:
9424 case ATTRIBUTE:
9425 case AUTHID:
9426 case BODY:
9427 case BULK:
9428 case BYTE:
9429 case CASCADE:
9430 case COALESCE:
9431 case COLLECT:
9432 case COLUMN:
9433 case COMMENT:
9434 case COMMIT:
9435 case CONSTRUCTOR:
9436 case CONTINUE:
9437 case CONVERT:
9438 case CURRENT:
9439 case CURSOR:
9440 case DATA:
9441 case DATE:
9442 case DAY:
9443 case DISABLE:
9444 case EDITIONABLE:
9445 case ELEMENT:
9446 case ENABLE:
9447 case ESCAPE:
9448 case EXCEPT:
9449 case EXCEPTIONS:
9450 case EXTERNAL:
9451 case EXTENDS:
9452 case EXTRACT:
9453 case FALSE:
9454 case FINAL:
9455 case FORCE:
9456 case FUNCTION:
9457 case GLOBAL:
9458 case HASH:
9459 case HEAP:
9460 case HOUR:
9461 case IMMEDIATE:
9462 case INDICES:
9463 case INDEXTYPE:
9464 case INDICATOR:
9465 case INSTANTIABLE:
9466 case INTERVAL:
9467 case INVALIDATE:
9468 case ISOLATION:
9469 case JAVA:
9470 case LEVEL:
9471 case LIMIT:
9472 case MAP:
9473 case MAX:
9474 case MEMBER:
9475 case MERGE:
9476 case MIN:
9477 case MINUTE:
9478 case MLSLABEL:
9479 case MODIFY:
9480 case MOD:
9481 case MONTH:
9482 case NATURAL:
9483 case NEW:
9484 case NEW_DOT:
9485 case NO:
9486 case NONEDITIONABLE:
9487 case NOT:
9488 case NULL:
9489 case NULLIF:
9490 case OBJECT:
9491 case OID:
9492 case OPAQUE:
9493 case OPERATOR:
9494 case ORGANIZATION:
9495 case OTHERS:
9496 case OVERRIDING:
9497 case PACKAGE:
9498 case PARTITION:
9499 case PRESERVE:
9500 case PRIVATE:
9501 case PROCEDURE:
9502 case RANGE:
9503 case RAW:
9504 case REAL:
9505 case RECORD:
9506 case REF:
9507 case RELEASE:
9508 case RELIES_ON:
9509 case RENAME:
9510 case RESULT:
9511 case RETURNING:
9512 case REVERSE:
9513 case ROLLBACK:
9514 case ROW:
9515 case ROWS:
9516 case ROWID:
9517 case ROWNUM:
9518 case SAVE:
9519 case SAVEPOINT:
9520 case SECOND:
9521 case SELECT:
9522 case SELF:
9523 case SET:
9524 case SPACE:
9525 case SQL:
9526 case SQLCODE:
9527 case SQLERRM:
9528 case STATIC:
9529 case SUBTYPE:
9530 case SUBSTITUTABLE:
9531 case SUCCESSFUL:
9532 case SYSDATE:
9533 case SYS_REFCURSOR:
9534 case TEMPORARY:
9535 case TIME:
9536 case TIMESTAMP:
9537 case TIMEZONE_REGION:
9538 case TIMEZONE_ABBR:
9539 case TIMEZONE_MINUTE:
9540 case TIMEZONE_HOUR:
9541 case TRANSACTION:
9542 case TRUE:
9543 case TYPE:
9544 case UNDER:
9545 case USING:
9546 case YES:
9547 case SHOW:
9548 case A:
9549 case DOUBLE:
9550 case DEC:
9551 case PRECISION:
9552 case INT:
9553 case NUMERIC:
9554 case NCHAR:
9555 case NVARCHAR2:
9556 case STRING:
9557 case UROWID:
9558 case VARRAY:
9559 case VARYING:
9560 case BFILE:
9561 case BLOB:
9562 case CLOB:
9563 case NCLOB:
9564 case YEAR:
9565 case LOCAL:
9566 case WITH:
9567 case ZONE:
9568 case CHARACTER:
9569 case AFTER:
9570 case BEFORE:
9571 case OLD:
9572 case PARENT:
9573 case ANALYZE:
9574 case ASSOCIATE:
9575 case AUDIT:
9576 case COMPOUND:
9577 case DATABASE:
9578 case CALL:
9579 case DDL:
9580 case DISASSOCIATE:
9581 case EACH:
9582 case FOLLOWS:
9583 case LOGOFF:
9584 case LOGON:
9585 case NESTED:
9586 case NOAUDIT:
9587 case SCHEMA:
9588 case SERVERERROR:
9589 case SHUTDOWN:
9590 case STARTUP:
9591 case STATEMENT:
9592 case STATISTICS:
9593 case SUSPEND:
9594 case TRUNCATE:
9595 case WRAPPED:
9596 case LIBRARY:
9597 case NAME:
9598 case STRUCT:
9599 case CONTEXT:
9600 case PARAMETERS:
9601 case LENGTH:
9602 case TDO:
9603 case MAXLEN:
9604 case CHARSETID:
9605 case CHARSETFORM:
9606 case ACCEPT:
9607 case ACCESSIBLE:
9608 case COPY:
9609 case DEFINE:
9610 case DISCONNECT:
9611 case HOST:
9612 case PRINT:
9613 case QUIT:
9614 case REMARK:
9615 case UNDEFINE:
9616 case VARIABLE:
9617 case WHENEVER:
9618 case ATTACH:
9619 case CAST:
9620 case TREAT:
9621 case TRIM:
9622 case LEFT:
9623 case RIGHT:
9624 case BOTH:
9625 case EMPTY:
9626 case MULTISET:
9627 case SUBMULTISET:
9628 case LEADING:
9629 case TRAILING:
9630 case CHAR_CS:
9631 case NCHAR_CS:
9632 case DBTIMEZONE:
9633 case SESSIONTIMEZONE:
9634 case AUTHENTICATED:
9635 case LINK:
9636 case SHARED:
9637 case DIRECTORY:
9638 case USER:
9639 case IDENTIFIER:
9640 case UNSIGNED_NUMERIC_LITERAL:
9641 case CHARACTER_LITERAL:
9642 case STRING_LITERAL:
9643 case QUOTED_LITERAL:
9644 Expression();
9645 jj_consume_token(4);
9646 break;
9647 default:
9648 jj_la1[120] = jj_gen;
9649 jj_consume_token(-1);
9650 throw new ParseException();
9651 }
9652 }
9653 jjtree.closeNodeScope(jjtn000, true);
9654 jjtc000 = false;
9655 {if (true) return jjtn000 ;}
9656 } catch (Throwable jjte000) {
9657 if (jjtc000) {
9658 jjtree.clearNodeScope(jjtn000);
9659 jjtc000 = false;
9660 } else {
9661 jjtree.popNode();
9662 }
9663 if (jjte000 instanceof RuntimeException) {
9664 {if (true) throw (RuntimeException)jjte000;}
9665 }
9666 if (jjte000 instanceof ParseException) {
9667 {if (true) throw (ParseException)jjte000;}
9668 }
9669 {if (true) throw (Error)jjte000;}
9670 } finally {
9671 if (jjtc000) {
9672 jjtree.closeNodeScope(jjtn000, true);
9673 }
9674 }
9675 throw new Error("Missing return statement in function");
9676 }
9677
9678 final public ASTStatement Statement() throws ParseException {
9679
9680 ASTStatement jjtn000 = new ASTStatement(this, JJTSTATEMENT);
9681 boolean jjtc000 = true;
9682 jjtree.openNodeScope(jjtn000);
9683 try {
9684 switch (jj_nt.kind) {
9685 case 21:
9686 LabelledStatement();
9687 break;
9688 case 5:
9689 case 16:
9690 case 17:
9691 case REPLACE:
9692 case DEFINER:
9693 case CURRENT_USER:
9694 case LANGUAGE:
9695 case ADD:
9696 case AGGREGATE:
9697 case ARRAY:
9698 case AT:
9699 case ATTRIBUTE:
9700 case AUTHID:
9701 case BEGIN:
9702 case BODY:
9703 case BULK:
9704 case BYTE:
9705 case CASCADE:
9706 case CASE:
9707 case CLOSE:
9708 case COALESCE:
9709 case COLLECT:
9710 case COLUMN:
9711 case COMMENT:
9712 case COMMIT:
9713 case CONSTRUCTOR:
9714 case CONTINUE:
9715 case CONVERT:
9716 case CURRENT:
9717 case CURSOR:
9718 case DATA:
9719 case DATE:
9720 case DAY:
9721 case DECLARE:
9722 case DELETE:
9723 case DISABLE:
9724 case EDITIONABLE:
9725 case ELEMENT:
9726 case ENABLE:
9727 case ESCAPE:
9728 case EXCEPT:
9729 case EXCEPTIONS:
9730 case EXECUTE:
9731 case EXIT:
9732 case EXTERNAL:
9733 case EXTENDS:
9734 case EXTRACT:
9735 case FALSE:
9736 case FETCH:
9737 case FINAL:
9738 case FOR:
9739 case FORALL:
9740 case FORCE:
9741 case FUNCTION:
9742 case GLOBAL:
9743 case GOTO:
9744 case HASH:
9745 case HEAP:
9746 case HOUR:
9747 case IF:
9748 case IMMEDIATE:
9749 case INDICES:
9750 case INDEXTYPE:
9751 case INDICATOR:
9752 case INSERT:
9753 case INSTANTIABLE:
9754 case INTERVAL:
9755 case INVALIDATE:
9756 case ISOLATION:
9757 case JAVA:
9758 case LEVEL:
9759 case LIMIT:
9760 case LOCK:
9761 case LOOP:
9762 case MAP:
9763 case MAX:
9764 case MEMBER:
9765 case MERGE:
9766 case MIN:
9767 case MINUTE:
9768 case MLSLABEL:
9769 case MODIFY:
9770 case MOD:
9771 case MONTH:
9772 case NATURAL:
9773 case NEW:
9774 case NEW_DOT:
9775 case NO:
9776 case NONEDITIONABLE:
9777 case NOT:
9778 case NULL:
9779 case NULLIF:
9780 case OBJECT:
9781 case OID:
9782 case OPAQUE:
9783 case OPEN:
9784 case OPERATOR:
9785 case ORGANIZATION:
9786 case OTHERS:
9787 case OVERRIDING:
9788 case PACKAGE:
9789 case PARTITION:
9790 case PIPE:
9791 case PRESERVE:
9792 case PRIVATE:
9793 case PROCEDURE:
9794 case RAISE:
9795 case RANGE:
9796 case RAW:
9797 case REAL:
9798 case RECORD:
9799 case REF:
9800 case RELEASE:
9801 case RELIES_ON:
9802 case RENAME:
9803 case RESULT:
9804 case RETURN:
9805 case RETURNING:
9806 case REVERSE:
9807 case ROLLBACK:
9808 case ROW:
9809 case ROWS:
9810 case ROWID:
9811 case ROWNUM:
9812 case SAVE:
9813 case SAVEPOINT:
9814 case SECOND:
9815 case SELECT:
9816 case SELF:
9817 case SET:
9818 case SPACE:
9819 case SQL:
9820 case SQLCODE:
9821 case SQLERRM:
9822 case STATIC:
9823 case SUBTYPE:
9824 case SUBSTITUTABLE:
9825 case SUCCESSFUL:
9826 case SYSDATE:
9827 case SYS_REFCURSOR:
9828 case TEMPORARY:
9829 case TIME:
9830 case TIMESTAMP:
9831 case TIMEZONE_REGION:
9832 case TIMEZONE_ABBR:
9833 case TIMEZONE_MINUTE:
9834 case TIMEZONE_HOUR:
9835 case TRANSACTION:
9836 case TRUE:
9837 case TYPE:
9838 case UNDER:
9839 case USING:
9840 case WHILE:
9841 case YES:
9842 case SHOW:
9843 case A:
9844 case UPDATE:
9845 case DOUBLE:
9846 case DEC:
9847 case PRECISION:
9848 case INT:
9849 case NUMERIC:
9850 case NCHAR:
9851 case NVARCHAR2:
9852 case STRING:
9853 case UROWID:
9854 case VARRAY:
9855 case VARYING:
9856 case BFILE:
9857 case BLOB:
9858 case CLOB:
9859 case NCLOB:
9860 case YEAR:
9861 case LOCAL:
9862 case WITH:
9863 case ZONE:
9864 case CHARACTER:
9865 case AFTER:
9866 case BEFORE:
9867 case OLD:
9868 case PARENT:
9869 case CC_IF:
9870 case CC_ERROR:
9871 case ANALYZE:
9872 case ASSOCIATE:
9873 case AUDIT:
9874 case COMPOUND:
9875 case DATABASE:
9876 case CALL:
9877 case DDL:
9878 case DISASSOCIATE:
9879 case EACH:
9880 case FOLLOWS:
9881 case LOGOFF:
9882 case LOGON:
9883 case NESTED:
9884 case NOAUDIT:
9885 case SCHEMA:
9886 case SERVERERROR:
9887 case SHUTDOWN:
9888 case STARTUP:
9889 case STATEMENT:
9890 case STATISTICS:
9891 case SUSPEND:
9892 case TRUNCATE:
9893 case WRAPPED:
9894 case LIBRARY:
9895 case NAME:
9896 case STRUCT:
9897 case CONTEXT:
9898 case PARAMETERS:
9899 case LENGTH:
9900 case TDO:
9901 case MAXLEN:
9902 case CHARSETID:
9903 case CHARSETFORM:
9904 case ACCEPT:
9905 case ACCESSIBLE:
9906 case COPY:
9907 case DEFINE:
9908 case DISCONNECT:
9909 case HOST:
9910 case PRINT:
9911 case QUIT:
9912 case REMARK:
9913 case UNDEFINE:
9914 case VARIABLE:
9915 case WHENEVER:
9916 case ATTACH:
9917 case CAST:
9918 case TREAT:
9919 case TRIM:
9920 case LEFT:
9921 case RIGHT:
9922 case BOTH:
9923 case EMPTY:
9924 case MULTISET:
9925 case SUBMULTISET:
9926 case LEADING:
9927 case TRAILING:
9928 case CHAR_CS:
9929 case NCHAR_CS:
9930 case DBTIMEZONE:
9931 case SESSIONTIMEZONE:
9932 case AUTHENTICATED:
9933 case LINK:
9934 case SHARED:
9935 case DIRECTORY:
9936 case USER:
9937 case IDENTIFIER:
9938 case UNSIGNED_NUMERIC_LITERAL:
9939 case CHARACTER_LITERAL:
9940 case STRING_LITERAL:
9941 case QUOTED_LITERAL:
9942 UnlabelledStatement();
9943 break;
9944 default:
9945 jj_la1[121] = jj_gen;
9946 jj_consume_token(-1);
9947 throw new ParseException();
9948 }
9949 jjtree.closeNodeScope(jjtn000, true);
9950 jjtc000 = false;
9951 {if (true) return jjtn000 ;}
9952 } catch (Throwable jjte000) {
9953 if (jjtc000) {
9954 jjtree.clearNodeScope(jjtn000);
9955 jjtc000 = false;
9956 } else {
9957 jjtree.popNode();
9958 }
9959 if (jjte000 instanceof RuntimeException) {
9960 {if (true) throw (RuntimeException)jjte000;}
9961 }
9962 if (jjte000 instanceof ParseException) {
9963 {if (true) throw (ParseException)jjte000;}
9964 }
9965 {if (true) throw (Error)jjte000;}
9966 } finally {
9967 if (jjtc000) {
9968 jjtree.closeNodeScope(jjtn000, true);
9969 }
9970 }
9971 throw new Error("Missing return statement in function");
9972 }
9973
9974
9975
9976
9977
9978 final public ASTLabelledStatement LabelledStatement() throws ParseException {
9979
9980 ASTLabelledStatement jjtn000 = new ASTLabelledStatement(this, JJTLABELLEDSTATEMENT);
9981 boolean jjtc000 = true;
9982 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
9983 try {
9984 label_24:
9985 while (true) {
9986 simpleNode = Label();
9987 switch (jj_nt.kind) {
9988 case 21:
9989 ;
9990 break;
9991 default:
9992 jj_la1[122] = jj_gen;
9993 break label_24;
9994 }
9995 }
9996 UnlabelledStatement();
9997 jjtree.closeNodeScope(jjtn000, true);
9998 jjtc000 = false;
9999 jjtn000.setImage( simpleNode.getImage() ) ;
10000 {if (true) return jjtn000 ;}
10001 } catch (Throwable jjte000) {
10002 if (jjtc000) {
10003 jjtree.clearNodeScope(jjtn000);
10004 jjtc000 = false;
10005 } else {
10006 jjtree.popNode();
10007 }
10008 if (jjte000 instanceof RuntimeException) {
10009 {if (true) throw (RuntimeException)jjte000;}
10010 }
10011 if (jjte000 instanceof ParseException) {
10012 {if (true) throw (ParseException)jjte000;}
10013 }
10014 {if (true) throw (Error)jjte000;}
10015 } finally {
10016 if (jjtc000) {
10017 jjtree.closeNodeScope(jjtn000, true);
10018 }
10019 }
10020 throw new Error("Missing return statement in function");
10021 }
10022
10023 final public ASTCaseStatement CaseStatement() throws ParseException {
10024
10025 ASTCaseStatement jjtn000 = new ASTCaseStatement(this, JJTCASESTATEMENT);
10026 boolean jjtc000 = true;
10027 jjtree.openNodeScope(jjtn000);
10028 try {
10029 jj_consume_token(CASE);
10030 switch (jj_nt.kind) {
10031 case 5:
10032 case 16:
10033 case 17:
10034 case REPLACE:
10035 case DEFINER:
10036 case CURRENT_USER:
10037 case LANGUAGE:
10038 case ADD:
10039 case AGGREGATE:
10040 case ARRAY:
10041 case AT:
10042 case ATTRIBUTE:
10043 case AUTHID:
10044 case BODY:
10045 case BULK:
10046 case BYTE:
10047 case CASCADE:
10048 case CASE:
10049 case CLOSE:
10050 case COALESCE:
10051 case COLLECT:
10052 case COLUMN:
10053 case COMMENT:
10054 case COMMIT:
10055 case CONSTRUCTOR:
10056 case CONTINUE:
10057 case CONVERT:
10058 case CURRENT:
10059 case CURSOR:
10060 case DATA:
10061 case DATE:
10062 case DAY:
10063 case DISABLE:
10064 case EDITIONABLE:
10065 case ELEMENT:
10066 case ENABLE:
10067 case ESCAPE:
10068 case EXCEPT:
10069 case EXCEPTIONS:
10070 case EXIT:
10071 case EXTERNAL:
10072 case EXTENDS:
10073 case EXTRACT:
10074 case FALSE:
10075 case FINAL:
10076 case FORCE:
10077 case FUNCTION:
10078 case GLOBAL:
10079 case HASH:
10080 case HEAP:
10081 case HOUR:
10082 case IMMEDIATE:
10083 case INDICES:
10084 case INDEXTYPE:
10085 case INDICATOR:
10086 case INSTANTIABLE:
10087 case INTERVAL:
10088 case INVALIDATE:
10089 case ISOLATION:
10090 case JAVA:
10091 case LEVEL:
10092 case LIMIT:
10093 case LOOP:
10094 case MAP:
10095 case MAX:
10096 case MEMBER:
10097 case MERGE:
10098 case MIN:
10099 case MINUTE:
10100 case MLSLABEL:
10101 case MODIFY:
10102 case MOD:
10103 case MONTH:
10104 case NATURAL:
10105 case NEW:
10106 case NEW_DOT:
10107 case NO:
10108 case NONEDITIONABLE:
10109 case NOT:
10110 case NULL:
10111 case NULLIF:
10112 case OBJECT:
10113 case OID:
10114 case OPAQUE:
10115 case OPEN:
10116 case OPERATOR:
10117 case ORGANIZATION:
10118 case OTHERS:
10119 case OVERRIDING:
10120 case PACKAGE:
10121 case PARTITION:
10122 case PRESERVE:
10123 case PRIVATE:
10124 case PROCEDURE:
10125 case RANGE:
10126 case RAW:
10127 case REAL:
10128 case RECORD:
10129 case REF:
10130 case RELEASE:
10131 case RELIES_ON:
10132 case RENAME:
10133 case RESULT:
10134 case RETURN:
10135 case RETURNING:
10136 case REVERSE:
10137 case ROLLBACK:
10138 case ROW:
10139 case ROWS:
10140 case ROWID:
10141 case ROWNUM:
10142 case SAVE:
10143 case SAVEPOINT:
10144 case SECOND:
10145 case SELECT:
10146 case SELF:
10147 case SET:
10148 case SPACE:
10149 case SQL:
10150 case SQLCODE:
10151 case SQLERRM:
10152 case STATIC:
10153 case SUBTYPE:
10154 case SUBSTITUTABLE:
10155 case SUCCESSFUL:
10156 case SYSDATE:
10157 case SYS_REFCURSOR:
10158 case TEMPORARY:
10159 case TIME:
10160 case TIMESTAMP:
10161 case TIMEZONE_REGION:
10162 case TIMEZONE_ABBR:
10163 case TIMEZONE_MINUTE:
10164 case TIMEZONE_HOUR:
10165 case TRANSACTION:
10166 case TRUE:
10167 case TYPE:
10168 case UNDER:
10169 case USING:
10170 case YES:
10171 case SHOW:
10172 case A:
10173 case DOUBLE:
10174 case DEC:
10175 case PRECISION:
10176 case INT:
10177 case NUMERIC:
10178 case NCHAR:
10179 case NVARCHAR2:
10180 case STRING:
10181 case UROWID:
10182 case VARRAY:
10183 case VARYING:
10184 case BFILE:
10185 case BLOB:
10186 case CLOB:
10187 case NCLOB:
10188 case YEAR:
10189 case LOCAL:
10190 case WITH:
10191 case ZONE:
10192 case CHARACTER:
10193 case AFTER:
10194 case BEFORE:
10195 case OLD:
10196 case PARENT:
10197 case CC_IF:
10198 case ANALYZE:
10199 case ASSOCIATE:
10200 case AUDIT:
10201 case COMPOUND:
10202 case DATABASE:
10203 case CALL:
10204 case DDL:
10205 case DISASSOCIATE:
10206 case EACH:
10207 case FOLLOWS:
10208 case LOGOFF:
10209 case LOGON:
10210 case NESTED:
10211 case NOAUDIT:
10212 case SCHEMA:
10213 case SERVERERROR:
10214 case SHUTDOWN:
10215 case STARTUP:
10216 case STATEMENT:
10217 case STATISTICS:
10218 case SUSPEND:
10219 case TRUNCATE:
10220 case WRAPPED:
10221 case LIBRARY:
10222 case NAME:
10223 case STRUCT:
10224 case CONTEXT:
10225 case PARAMETERS:
10226 case LENGTH:
10227 case TDO:
10228 case MAXLEN:
10229 case CHARSETID:
10230 case CHARSETFORM:
10231 case ACCEPT:
10232 case ACCESSIBLE:
10233 case COPY:
10234 case DEFINE:
10235 case DISCONNECT:
10236 case HOST:
10237 case PRINT:
10238 case QUIT:
10239 case REMARK:
10240 case UNDEFINE:
10241 case VARIABLE:
10242 case WHENEVER:
10243 case ATTACH:
10244 case CAST:
10245 case TREAT:
10246 case TRIM:
10247 case LEFT:
10248 case RIGHT:
10249 case BOTH:
10250 case EMPTY:
10251 case MULTISET:
10252 case SUBMULTISET:
10253 case LEADING:
10254 case TRAILING:
10255 case CHAR_CS:
10256 case NCHAR_CS:
10257 case DBTIMEZONE:
10258 case SESSIONTIMEZONE:
10259 case AUTHENTICATED:
10260 case LINK:
10261 case SHARED:
10262 case DIRECTORY:
10263 case USER:
10264 case IDENTIFIER:
10265 case UNSIGNED_NUMERIC_LITERAL:
10266 case CHARACTER_LITERAL:
10267 case STRING_LITERAL:
10268 case QUOTED_LITERAL:
10269 Expression();
10270 break;
10271 default:
10272 jj_la1[123] = jj_gen;
10273 ;
10274 }
10275 label_25:
10276 while (true) {
10277 switch (jj_nt.kind) {
10278 case WHEN:
10279 ;
10280 break;
10281 default:
10282 jj_la1[124] = jj_gen;
10283 break label_25;
10284 }
10285 CaseWhenClause();
10286 }
10287 switch (jj_nt.kind) {
10288 case ELSE:
10289 ElseClause();
10290 break;
10291 default:
10292 jj_la1[125] = jj_gen;
10293 ;
10294 }
10295 jj_consume_token(END);
10296 jj_consume_token(CASE);
10297 switch (jj_nt.kind) {
10298 case IDENTIFIER:
10299 jj_consume_token(IDENTIFIER);
10300 break;
10301 default:
10302 jj_la1[126] = jj_gen;
10303 ;
10304 }
10305 jjtree.closeNodeScope(jjtn000, true);
10306 jjtc000 = false;
10307 {if (true) return jjtn000 ;}
10308 } catch (Throwable jjte000) {
10309 if (jjtc000) {
10310 jjtree.clearNodeScope(jjtn000);
10311 jjtc000 = false;
10312 } else {
10313 jjtree.popNode();
10314 }
10315 if (jjte000 instanceof RuntimeException) {
10316 {if (true) throw (RuntimeException)jjte000;}
10317 }
10318 if (jjte000 instanceof ParseException) {
10319 {if (true) throw (ParseException)jjte000;}
10320 }
10321 {if (true) throw (Error)jjte000;}
10322 } finally {
10323 if (jjtc000) {
10324 jjtree.closeNodeScope(jjtn000, true);
10325 }
10326 }
10327 throw new Error("Missing return statement in function");
10328 }
10329
10330 final public ASTCaseWhenClause CaseWhenClause() throws ParseException {
10331
10332 ASTCaseWhenClause jjtn000 = new ASTCaseWhenClause(this, JJTCASEWHENCLAUSE);
10333 boolean jjtc000 = true;
10334 jjtree.openNodeScope(jjtn000);
10335 try {
10336 jj_consume_token(WHEN);
10337 Expression();
10338 jj_consume_token(THEN);
10339 label_26:
10340 while (true) {
10341 Statement();
10342 switch (jj_nt.kind) {
10343 case 5:
10344 case 16:
10345 case 17:
10346 case 21:
10347 case REPLACE:
10348 case DEFINER:
10349 case CURRENT_USER:
10350 case LANGUAGE:
10351 case ADD:
10352 case AGGREGATE:
10353 case ARRAY:
10354 case AT:
10355 case ATTRIBUTE:
10356 case AUTHID:
10357 case BEGIN:
10358 case BODY:
10359 case BULK:
10360 case BYTE:
10361 case CASCADE:
10362 case CASE:
10363 case CLOSE:
10364 case COALESCE:
10365 case COLLECT:
10366 case COLUMN:
10367 case COMMENT:
10368 case COMMIT:
10369 case CONSTRUCTOR:
10370 case CONTINUE:
10371 case CONVERT:
10372 case CURRENT:
10373 case CURSOR:
10374 case DATA:
10375 case DATE:
10376 case DAY:
10377 case DECLARE:
10378 case DELETE:
10379 case DISABLE:
10380 case EDITIONABLE:
10381 case ELEMENT:
10382 case ENABLE:
10383 case ESCAPE:
10384 case EXCEPT:
10385 case EXCEPTIONS:
10386 case EXECUTE:
10387 case EXIT:
10388 case EXTERNAL:
10389 case EXTENDS:
10390 case EXTRACT:
10391 case FALSE:
10392 case FETCH:
10393 case FINAL:
10394 case FOR:
10395 case FORALL:
10396 case FORCE:
10397 case FUNCTION:
10398 case GLOBAL:
10399 case GOTO:
10400 case HASH:
10401 case HEAP:
10402 case HOUR:
10403 case IF:
10404 case IMMEDIATE:
10405 case INDICES:
10406 case INDEXTYPE:
10407 case INDICATOR:
10408 case INSERT:
10409 case INSTANTIABLE:
10410 case INTERVAL:
10411 case INVALIDATE:
10412 case ISOLATION:
10413 case JAVA:
10414 case LEVEL:
10415 case LIMIT:
10416 case LOCK:
10417 case LOOP:
10418 case MAP:
10419 case MAX:
10420 case MEMBER:
10421 case MERGE:
10422 case MIN:
10423 case MINUTE:
10424 case MLSLABEL:
10425 case MODIFY:
10426 case MOD:
10427 case MONTH:
10428 case NATURAL:
10429 case NEW:
10430 case NEW_DOT:
10431 case NO:
10432 case NONEDITIONABLE:
10433 case NOT:
10434 case NULL:
10435 case NULLIF:
10436 case OBJECT:
10437 case OID:
10438 case OPAQUE:
10439 case OPEN:
10440 case OPERATOR:
10441 case ORGANIZATION:
10442 case OTHERS:
10443 case OVERRIDING:
10444 case PACKAGE:
10445 case PARTITION:
10446 case PIPE:
10447 case PRESERVE:
10448 case PRIVATE:
10449 case PROCEDURE:
10450 case RAISE:
10451 case RANGE:
10452 case RAW:
10453 case REAL:
10454 case RECORD:
10455 case REF:
10456 case RELEASE:
10457 case RELIES_ON:
10458 case RENAME:
10459 case RESULT:
10460 case RETURN:
10461 case RETURNING:
10462 case REVERSE:
10463 case ROLLBACK:
10464 case ROW:
10465 case ROWS:
10466 case ROWID:
10467 case ROWNUM:
10468 case SAVE:
10469 case SAVEPOINT:
10470 case SECOND:
10471 case SELECT:
10472 case SELF:
10473 case SET:
10474 case SPACE:
10475 case SQL:
10476 case SQLCODE:
10477 case SQLERRM:
10478 case STATIC:
10479 case SUBTYPE:
10480 case SUBSTITUTABLE:
10481 case SUCCESSFUL:
10482 case SYSDATE:
10483 case SYS_REFCURSOR:
10484 case TEMPORARY:
10485 case TIME:
10486 case TIMESTAMP:
10487 case TIMEZONE_REGION:
10488 case TIMEZONE_ABBR:
10489 case TIMEZONE_MINUTE:
10490 case TIMEZONE_HOUR:
10491 case TRANSACTION:
10492 case TRUE:
10493 case TYPE:
10494 case UNDER:
10495 case USING:
10496 case WHILE:
10497 case YES:
10498 case SHOW:
10499 case A:
10500 case UPDATE:
10501 case DOUBLE:
10502 case DEC:
10503 case PRECISION:
10504 case INT:
10505 case NUMERIC:
10506 case NCHAR:
10507 case NVARCHAR2:
10508 case STRING:
10509 case UROWID:
10510 case VARRAY:
10511 case VARYING:
10512 case BFILE:
10513 case BLOB:
10514 case CLOB:
10515 case NCLOB:
10516 case YEAR:
10517 case LOCAL:
10518 case WITH:
10519 case ZONE:
10520 case CHARACTER:
10521 case AFTER:
10522 case BEFORE:
10523 case OLD:
10524 case PARENT:
10525 case CC_IF:
10526 case CC_ERROR:
10527 case ANALYZE:
10528 case ASSOCIATE:
10529 case AUDIT:
10530 case COMPOUND:
10531 case DATABASE:
10532 case CALL:
10533 case DDL:
10534 case DISASSOCIATE:
10535 case EACH:
10536 case FOLLOWS:
10537 case LOGOFF:
10538 case LOGON:
10539 case NESTED:
10540 case NOAUDIT:
10541 case SCHEMA:
10542 case SERVERERROR:
10543 case SHUTDOWN:
10544 case STARTUP:
10545 case STATEMENT:
10546 case STATISTICS:
10547 case SUSPEND:
10548 case TRUNCATE:
10549 case WRAPPED:
10550 case LIBRARY:
10551 case NAME:
10552 case STRUCT:
10553 case CONTEXT:
10554 case PARAMETERS:
10555 case LENGTH:
10556 case TDO:
10557 case MAXLEN:
10558 case CHARSETID:
10559 case CHARSETFORM:
10560 case ACCEPT:
10561 case ACCESSIBLE:
10562 case COPY:
10563 case DEFINE:
10564 case DISCONNECT:
10565 case HOST:
10566 case PRINT:
10567 case QUIT:
10568 case REMARK:
10569 case UNDEFINE:
10570 case VARIABLE:
10571 case WHENEVER:
10572 case ATTACH:
10573 case CAST:
10574 case TREAT:
10575 case TRIM:
10576 case LEFT:
10577 case RIGHT:
10578 case BOTH:
10579 case EMPTY:
10580 case MULTISET:
10581 case SUBMULTISET:
10582 case LEADING:
10583 case TRAILING:
10584 case CHAR_CS:
10585 case NCHAR_CS:
10586 case DBTIMEZONE:
10587 case SESSIONTIMEZONE:
10588 case AUTHENTICATED:
10589 case LINK:
10590 case SHARED:
10591 case DIRECTORY:
10592 case USER:
10593 case IDENTIFIER:
10594 case UNSIGNED_NUMERIC_LITERAL:
10595 case CHARACTER_LITERAL:
10596 case STRING_LITERAL:
10597 case QUOTED_LITERAL:
10598 ;
10599 break;
10600 default:
10601 jj_la1[127] = jj_gen;
10602 break label_26;
10603 }
10604 }
10605 jjtree.closeNodeScope(jjtn000, true);
10606 jjtc000 = false;
10607 {if (true) return jjtn000 ;}
10608 } catch (Throwable jjte000) {
10609 if (jjtc000) {
10610 jjtree.clearNodeScope(jjtn000);
10611 jjtc000 = false;
10612 } else {
10613 jjtree.popNode();
10614 }
10615 if (jjte000 instanceof RuntimeException) {
10616 {if (true) throw (RuntimeException)jjte000;}
10617 }
10618 if (jjte000 instanceof ParseException) {
10619 {if (true) throw (ParseException)jjte000;}
10620 }
10621 {if (true) throw (Error)jjte000;}
10622 } finally {
10623 if (jjtc000) {
10624 jjtree.closeNodeScope(jjtn000, true);
10625 }
10626 }
10627 throw new Error("Missing return statement in function");
10628 }
10629
10630 final public ASTElseClause ElseClause() throws ParseException {
10631
10632 ASTElseClause jjtn000 = new ASTElseClause(this, JJTELSECLAUSE);
10633 boolean jjtc000 = true;
10634 jjtree.openNodeScope(jjtn000);
10635 try {
10636 jj_consume_token(ELSE);
10637 label_27:
10638 while (true) {
10639 Statement();
10640 switch (jj_nt.kind) {
10641 case 5:
10642 case 16:
10643 case 17:
10644 case 21:
10645 case REPLACE:
10646 case DEFINER:
10647 case CURRENT_USER:
10648 case LANGUAGE:
10649 case ADD:
10650 case AGGREGATE:
10651 case ARRAY:
10652 case AT:
10653 case ATTRIBUTE:
10654 case AUTHID:
10655 case BEGIN:
10656 case BODY:
10657 case BULK:
10658 case BYTE:
10659 case CASCADE:
10660 case CASE:
10661 case CLOSE:
10662 case COALESCE:
10663 case COLLECT:
10664 case COLUMN:
10665 case COMMENT:
10666 case COMMIT:
10667 case CONSTRUCTOR:
10668 case CONTINUE:
10669 case CONVERT:
10670 case CURRENT:
10671 case CURSOR:
10672 case DATA:
10673 case DATE:
10674 case DAY:
10675 case DECLARE:
10676 case DELETE:
10677 case DISABLE:
10678 case EDITIONABLE:
10679 case ELEMENT:
10680 case ENABLE:
10681 case ESCAPE:
10682 case EXCEPT:
10683 case EXCEPTIONS:
10684 case EXECUTE:
10685 case EXIT:
10686 case EXTERNAL:
10687 case EXTENDS:
10688 case EXTRACT:
10689 case FALSE:
10690 case FETCH:
10691 case FINAL:
10692 case FOR:
10693 case FORALL:
10694 case FORCE:
10695 case FUNCTION:
10696 case GLOBAL:
10697 case GOTO:
10698 case HASH:
10699 case HEAP:
10700 case HOUR:
10701 case IF:
10702 case IMMEDIATE:
10703 case INDICES:
10704 case INDEXTYPE:
10705 case INDICATOR:
10706 case INSERT:
10707 case INSTANTIABLE:
10708 case INTERVAL:
10709 case INVALIDATE:
10710 case ISOLATION:
10711 case JAVA:
10712 case LEVEL:
10713 case LIMIT:
10714 case LOCK:
10715 case LOOP:
10716 case MAP:
10717 case MAX:
10718 case MEMBER:
10719 case MERGE:
10720 case MIN:
10721 case MINUTE:
10722 case MLSLABEL:
10723 case MODIFY:
10724 case MOD:
10725 case MONTH:
10726 case NATURAL:
10727 case NEW:
10728 case NEW_DOT:
10729 case NO:
10730 case NONEDITIONABLE:
10731 case NOT:
10732 case NULL:
10733 case NULLIF:
10734 case OBJECT:
10735 case OID:
10736 case OPAQUE:
10737 case OPEN:
10738 case OPERATOR:
10739 case ORGANIZATION:
10740 case OTHERS:
10741 case OVERRIDING:
10742 case PACKAGE:
10743 case PARTITION:
10744 case PIPE:
10745 case PRESERVE:
10746 case PRIVATE:
10747 case PROCEDURE:
10748 case RAISE:
10749 case RANGE:
10750 case RAW:
10751 case REAL:
10752 case RECORD:
10753 case REF:
10754 case RELEASE:
10755 case RELIES_ON:
10756 case RENAME:
10757 case RESULT:
10758 case RETURN:
10759 case RETURNING:
10760 case REVERSE:
10761 case ROLLBACK:
10762 case ROW:
10763 case ROWS:
10764 case ROWID:
10765 case ROWNUM:
10766 case SAVE:
10767 case SAVEPOINT:
10768 case SECOND:
10769 case SELECT:
10770 case SELF:
10771 case SET:
10772 case SPACE:
10773 case SQL:
10774 case SQLCODE:
10775 case SQLERRM:
10776 case STATIC:
10777 case SUBTYPE:
10778 case SUBSTITUTABLE:
10779 case SUCCESSFUL:
10780 case SYSDATE:
10781 case SYS_REFCURSOR:
10782 case TEMPORARY:
10783 case TIME:
10784 case TIMESTAMP:
10785 case TIMEZONE_REGION:
10786 case TIMEZONE_ABBR:
10787 case TIMEZONE_MINUTE:
10788 case TIMEZONE_HOUR:
10789 case TRANSACTION:
10790 case TRUE:
10791 case TYPE:
10792 case UNDER:
10793 case USING:
10794 case WHILE:
10795 case YES:
10796 case SHOW:
10797 case A:
10798 case UPDATE:
10799 case DOUBLE:
10800 case DEC:
10801 case PRECISION:
10802 case INT:
10803 case NUMERIC:
10804 case NCHAR:
10805 case NVARCHAR2:
10806 case STRING:
10807 case UROWID:
10808 case VARRAY:
10809 case VARYING:
10810 case BFILE:
10811 case BLOB:
10812 case CLOB:
10813 case NCLOB:
10814 case YEAR:
10815 case LOCAL:
10816 case WITH:
10817 case ZONE:
10818 case CHARACTER:
10819 case AFTER:
10820 case BEFORE:
10821 case OLD:
10822 case PARENT:
10823 case CC_IF:
10824 case CC_ERROR:
10825 case ANALYZE:
10826 case ASSOCIATE:
10827 case AUDIT:
10828 case COMPOUND:
10829 case DATABASE:
10830 case CALL:
10831 case DDL:
10832 case DISASSOCIATE:
10833 case EACH:
10834 case FOLLOWS:
10835 case LOGOFF:
10836 case LOGON:
10837 case NESTED:
10838 case NOAUDIT:
10839 case SCHEMA:
10840 case SERVERERROR:
10841 case SHUTDOWN:
10842 case STARTUP:
10843 case STATEMENT:
10844 case STATISTICS:
10845 case SUSPEND:
10846 case TRUNCATE:
10847 case WRAPPED:
10848 case LIBRARY:
10849 case NAME:
10850 case STRUCT:
10851 case CONTEXT:
10852 case PARAMETERS:
10853 case LENGTH:
10854 case TDO:
10855 case MAXLEN:
10856 case CHARSETID:
10857 case CHARSETFORM:
10858 case ACCEPT:
10859 case ACCESSIBLE:
10860 case COPY:
10861 case DEFINE:
10862 case DISCONNECT:
10863 case HOST:
10864 case PRINT:
10865 case QUIT:
10866 case REMARK:
10867 case UNDEFINE:
10868 case VARIABLE:
10869 case WHENEVER:
10870 case ATTACH:
10871 case CAST:
10872 case TREAT:
10873 case TRIM:
10874 case LEFT:
10875 case RIGHT:
10876 case BOTH:
10877 case EMPTY:
10878 case MULTISET:
10879 case SUBMULTISET:
10880 case LEADING:
10881 case TRAILING:
10882 case CHAR_CS:
10883 case NCHAR_CS:
10884 case DBTIMEZONE:
10885 case SESSIONTIMEZONE:
10886 case AUTHENTICATED:
10887 case LINK:
10888 case SHARED:
10889 case DIRECTORY:
10890 case USER:
10891 case IDENTIFIER:
10892 case UNSIGNED_NUMERIC_LITERAL:
10893 case CHARACTER_LITERAL:
10894 case STRING_LITERAL:
10895 case QUOTED_LITERAL:
10896 ;
10897 break;
10898 default:
10899 jj_la1[128] = jj_gen;
10900 break label_27;
10901 }
10902 }
10903 jjtree.closeNodeScope(jjtn000, true);
10904 jjtc000 = false;
10905 {if (true) return jjtn000 ;}
10906 } catch (Throwable jjte000) {
10907 if (jjtc000) {
10908 jjtree.clearNodeScope(jjtn000);
10909 jjtc000 = false;
10910 } else {
10911 jjtree.popNode();
10912 }
10913 if (jjte000 instanceof RuntimeException) {
10914 {if (true) throw (RuntimeException)jjte000;}
10915 }
10916 if (jjte000 instanceof ParseException) {
10917 {if (true) throw (ParseException)jjte000;}
10918 }
10919 {if (true) throw (Error)jjte000;}
10920 } finally {
10921 if (jjtc000) {
10922 jjtree.closeNodeScope(jjtn000, true);
10923 }
10924 }
10925 throw new Error("Missing return statement in function");
10926 }
10927
10928 final public ASTElsifClause ElsifClause() throws ParseException {
10929
10930 ASTElsifClause jjtn000 = new ASTElsifClause(this, JJTELSIFCLAUSE);
10931 boolean jjtc000 = true;
10932 jjtree.openNodeScope(jjtn000);
10933 try {
10934 jj_consume_token(ELSIF);
10935 Expression();
10936 jj_consume_token(THEN);
10937 label_28:
10938 while (true) {
10939 Statement();
10940 switch (jj_nt.kind) {
10941 case 5:
10942 case 16:
10943 case 17:
10944 case 21:
10945 case REPLACE:
10946 case DEFINER:
10947 case CURRENT_USER:
10948 case LANGUAGE:
10949 case ADD:
10950 case AGGREGATE:
10951 case ARRAY:
10952 case AT:
10953 case ATTRIBUTE:
10954 case AUTHID:
10955 case BEGIN:
10956 case BODY:
10957 case BULK:
10958 case BYTE:
10959 case CASCADE:
10960 case CASE:
10961 case CLOSE:
10962 case COALESCE:
10963 case COLLECT:
10964 case COLUMN:
10965 case COMMENT:
10966 case COMMIT:
10967 case CONSTRUCTOR:
10968 case CONTINUE:
10969 case CONVERT:
10970 case CURRENT:
10971 case CURSOR:
10972 case DATA:
10973 case DATE:
10974 case DAY:
10975 case DECLARE:
10976 case DELETE:
10977 case DISABLE:
10978 case EDITIONABLE:
10979 case ELEMENT:
10980 case ENABLE:
10981 case ESCAPE:
10982 case EXCEPT:
10983 case EXCEPTIONS:
10984 case EXECUTE:
10985 case EXIT:
10986 case EXTERNAL:
10987 case EXTENDS:
10988 case EXTRACT:
10989 case FALSE:
10990 case FETCH:
10991 case FINAL:
10992 case FOR:
10993 case FORALL:
10994 case FORCE:
10995 case FUNCTION:
10996 case GLOBAL:
10997 case GOTO:
10998 case HASH:
10999 case HEAP:
11000 case HOUR:
11001 case IF:
11002 case IMMEDIATE:
11003 case INDICES:
11004 case INDEXTYPE:
11005 case INDICATOR:
11006 case INSERT:
11007 case INSTANTIABLE:
11008 case INTERVAL:
11009 case INVALIDATE:
11010 case ISOLATION:
11011 case JAVA:
11012 case LEVEL:
11013 case LIMIT:
11014 case LOCK:
11015 case LOOP:
11016 case MAP:
11017 case MAX:
11018 case MEMBER:
11019 case MERGE:
11020 case MIN:
11021 case MINUTE:
11022 case MLSLABEL:
11023 case MODIFY:
11024 case MOD:
11025 case MONTH:
11026 case NATURAL:
11027 case NEW:
11028 case NEW_DOT:
11029 case NO:
11030 case NONEDITIONABLE:
11031 case NOT:
11032 case NULL:
11033 case NULLIF:
11034 case OBJECT:
11035 case OID:
11036 case OPAQUE:
11037 case OPEN:
11038 case OPERATOR:
11039 case ORGANIZATION:
11040 case OTHERS:
11041 case OVERRIDING:
11042 case PACKAGE:
11043 case PARTITION:
11044 case PIPE:
11045 case PRESERVE:
11046 case PRIVATE:
11047 case PROCEDURE:
11048 case RAISE:
11049 case RANGE:
11050 case RAW:
11051 case REAL:
11052 case RECORD:
11053 case REF:
11054 case RELEASE:
11055 case RELIES_ON:
11056 case RENAME:
11057 case RESULT:
11058 case RETURN:
11059 case RETURNING:
11060 case REVERSE:
11061 case ROLLBACK:
11062 case ROW:
11063 case ROWS:
11064 case ROWID:
11065 case ROWNUM:
11066 case SAVE:
11067 case SAVEPOINT:
11068 case SECOND:
11069 case SELECT:
11070 case SELF:
11071 case SET:
11072 case SPACE:
11073 case SQL:
11074 case SQLCODE:
11075 case SQLERRM:
11076 case STATIC:
11077 case SUBTYPE:
11078 case SUBSTITUTABLE:
11079 case SUCCESSFUL:
11080 case SYSDATE:
11081 case SYS_REFCURSOR:
11082 case TEMPORARY:
11083 case TIME:
11084 case TIMESTAMP:
11085 case TIMEZONE_REGION:
11086 case TIMEZONE_ABBR:
11087 case TIMEZONE_MINUTE:
11088 case TIMEZONE_HOUR:
11089 case TRANSACTION:
11090 case TRUE:
11091 case TYPE:
11092 case UNDER:
11093 case USING:
11094 case WHILE:
11095 case YES:
11096 case SHOW:
11097 case A:
11098 case UPDATE:
11099 case DOUBLE:
11100 case DEC:
11101 case PRECISION:
11102 case INT:
11103 case NUMERIC:
11104 case NCHAR:
11105 case NVARCHAR2:
11106 case STRING:
11107 case UROWID:
11108 case VARRAY:
11109 case VARYING:
11110 case BFILE:
11111 case BLOB:
11112 case CLOB:
11113 case NCLOB:
11114 case YEAR:
11115 case LOCAL:
11116 case WITH:
11117 case ZONE:
11118 case CHARACTER:
11119 case AFTER:
11120 case BEFORE:
11121 case OLD:
11122 case PARENT:
11123 case CC_IF:
11124 case CC_ERROR:
11125 case ANALYZE:
11126 case ASSOCIATE:
11127 case AUDIT:
11128 case COMPOUND:
11129 case DATABASE:
11130 case CALL:
11131 case DDL:
11132 case DISASSOCIATE:
11133 case EACH:
11134 case FOLLOWS:
11135 case LOGOFF:
11136 case LOGON:
11137 case NESTED:
11138 case NOAUDIT:
11139 case SCHEMA:
11140 case SERVERERROR:
11141 case SHUTDOWN:
11142 case STARTUP:
11143 case STATEMENT:
11144 case STATISTICS:
11145 case SUSPEND:
11146 case TRUNCATE:
11147 case WRAPPED:
11148 case LIBRARY:
11149 case NAME:
11150 case STRUCT:
11151 case CONTEXT:
11152 case PARAMETERS:
11153 case LENGTH:
11154 case TDO:
11155 case MAXLEN:
11156 case CHARSETID:
11157 case CHARSETFORM:
11158 case ACCEPT:
11159 case ACCESSIBLE:
11160 case COPY:
11161 case DEFINE:
11162 case DISCONNECT:
11163 case HOST:
11164 case PRINT:
11165 case QUIT:
11166 case REMARK:
11167 case UNDEFINE:
11168 case VARIABLE:
11169 case WHENEVER:
11170 case ATTACH:
11171 case CAST:
11172 case TREAT:
11173 case TRIM:
11174 case LEFT:
11175 case RIGHT:
11176 case BOTH:
11177 case EMPTY:
11178 case MULTISET:
11179 case SUBMULTISET:
11180 case LEADING:
11181 case TRAILING:
11182 case CHAR_CS:
11183 case NCHAR_CS:
11184 case DBTIMEZONE:
11185 case SESSIONTIMEZONE:
11186 case AUTHENTICATED:
11187 case LINK:
11188 case SHARED:
11189 case DIRECTORY:
11190 case USER:
11191 case IDENTIFIER:
11192 case UNSIGNED_NUMERIC_LITERAL:
11193 case CHARACTER_LITERAL:
11194 case STRING_LITERAL:
11195 case QUOTED_LITERAL:
11196 ;
11197 break;
11198 default:
11199 jj_la1[129] = jj_gen;
11200 break label_28;
11201 }
11202 }
11203 jjtree.closeNodeScope(jjtn000, true);
11204 jjtc000 = false;
11205 {if (true) return jjtn000 ;}
11206 } catch (Throwable jjte000) {
11207 if (jjtc000) {
11208 jjtree.clearNodeScope(jjtn000);
11209 jjtc000 = false;
11210 } else {
11211 jjtree.popNode();
11212 }
11213 if (jjte000 instanceof RuntimeException) {
11214 {if (true) throw (RuntimeException)jjte000;}
11215 }
11216 if (jjte000 instanceof ParseException) {
11217 {if (true) throw (ParseException)jjte000;}
11218 }
11219 {if (true) throw (Error)jjte000;}
11220 } finally {
11221 if (jjtc000) {
11222 jjtree.closeNodeScope(jjtn000, true);
11223 }
11224 }
11225 throw new Error("Missing return statement in function");
11226 }
11227
11228 final public ASTLoopStatement LoopStatement() throws ParseException {
11229
11230 ASTLoopStatement jjtn000 = new ASTLoopStatement(this, JJTLOOPSTATEMENT);
11231 boolean jjtc000 = true;
11232 jjtree.openNodeScope(jjtn000);
11233 try {
11234 jj_consume_token(LOOP);
11235 label_29:
11236 while (true) {
11237 Statement();
11238 switch (jj_nt.kind) {
11239 case 5:
11240 case 16:
11241 case 17:
11242 case 21:
11243 case REPLACE:
11244 case DEFINER:
11245 case CURRENT_USER:
11246 case LANGUAGE:
11247 case ADD:
11248 case AGGREGATE:
11249 case ARRAY:
11250 case AT:
11251 case ATTRIBUTE:
11252 case AUTHID:
11253 case BEGIN:
11254 case BODY:
11255 case BULK:
11256 case BYTE:
11257 case CASCADE:
11258 case CASE:
11259 case CLOSE:
11260 case COALESCE:
11261 case COLLECT:
11262 case COLUMN:
11263 case COMMENT:
11264 case COMMIT:
11265 case CONSTRUCTOR:
11266 case CONTINUE:
11267 case CONVERT:
11268 case CURRENT:
11269 case CURSOR:
11270 case DATA:
11271 case DATE:
11272 case DAY:
11273 case DECLARE:
11274 case DELETE:
11275 case DISABLE:
11276 case EDITIONABLE:
11277 case ELEMENT:
11278 case ENABLE:
11279 case ESCAPE:
11280 case EXCEPT:
11281 case EXCEPTIONS:
11282 case EXECUTE:
11283 case EXIT:
11284 case EXTERNAL:
11285 case EXTENDS:
11286 case EXTRACT:
11287 case FALSE:
11288 case FETCH:
11289 case FINAL:
11290 case FOR:
11291 case FORALL:
11292 case FORCE:
11293 case FUNCTION:
11294 case GLOBAL:
11295 case GOTO:
11296 case HASH:
11297 case HEAP:
11298 case HOUR:
11299 case IF:
11300 case IMMEDIATE:
11301 case INDICES:
11302 case INDEXTYPE:
11303 case INDICATOR:
11304 case INSERT:
11305 case INSTANTIABLE:
11306 case INTERVAL:
11307 case INVALIDATE:
11308 case ISOLATION:
11309 case JAVA:
11310 case LEVEL:
11311 case LIMIT:
11312 case LOCK:
11313 case LOOP:
11314 case MAP:
11315 case MAX:
11316 case MEMBER:
11317 case MERGE:
11318 case MIN:
11319 case MINUTE:
11320 case MLSLABEL:
11321 case MODIFY:
11322 case MOD:
11323 case MONTH:
11324 case NATURAL:
11325 case NEW:
11326 case NEW_DOT:
11327 case NO:
11328 case NONEDITIONABLE:
11329 case NOT:
11330 case NULL:
11331 case NULLIF:
11332 case OBJECT:
11333 case OID:
11334 case OPAQUE:
11335 case OPEN:
11336 case OPERATOR:
11337 case ORGANIZATION:
11338 case OTHERS:
11339 case OVERRIDING:
11340 case PACKAGE:
11341 case PARTITION:
11342 case PIPE:
11343 case PRESERVE:
11344 case PRIVATE:
11345 case PROCEDURE:
11346 case RAISE:
11347 case RANGE:
11348 case RAW:
11349 case REAL:
11350 case RECORD:
11351 case REF:
11352 case RELEASE:
11353 case RELIES_ON:
11354 case RENAME:
11355 case RESULT:
11356 case RETURN:
11357 case RETURNING:
11358 case REVERSE:
11359 case ROLLBACK:
11360 case ROW:
11361 case ROWS:
11362 case ROWID:
11363 case ROWNUM:
11364 case SAVE:
11365 case SAVEPOINT:
11366 case SECOND:
11367 case SELECT:
11368 case SELF:
11369 case SET:
11370 case SPACE:
11371 case SQL:
11372 case SQLCODE:
11373 case SQLERRM:
11374 case STATIC:
11375 case SUBTYPE:
11376 case SUBSTITUTABLE:
11377 case SUCCESSFUL:
11378 case SYSDATE:
11379 case SYS_REFCURSOR:
11380 case TEMPORARY:
11381 case TIME:
11382 case TIMESTAMP:
11383 case TIMEZONE_REGION:
11384 case TIMEZONE_ABBR:
11385 case TIMEZONE_MINUTE:
11386 case TIMEZONE_HOUR:
11387 case TRANSACTION:
11388 case TRUE:
11389 case TYPE:
11390 case UNDER:
11391 case USING:
11392 case WHILE:
11393 case YES:
11394 case SHOW:
11395 case A:
11396 case UPDATE:
11397 case DOUBLE:
11398 case DEC:
11399 case PRECISION:
11400 case INT:
11401 case NUMERIC:
11402 case NCHAR:
11403 case NVARCHAR2:
11404 case STRING:
11405 case UROWID:
11406 case VARRAY:
11407 case VARYING:
11408 case BFILE:
11409 case BLOB:
11410 case CLOB:
11411 case NCLOB:
11412 case YEAR:
11413 case LOCAL:
11414 case WITH:
11415 case ZONE:
11416 case CHARACTER:
11417 case AFTER:
11418 case BEFORE:
11419 case OLD:
11420 case PARENT:
11421 case CC_IF:
11422 case CC_ERROR:
11423 case ANALYZE:
11424 case ASSOCIATE:
11425 case AUDIT:
11426 case COMPOUND:
11427 case DATABASE:
11428 case CALL:
11429 case DDL:
11430 case DISASSOCIATE:
11431 case EACH:
11432 case FOLLOWS:
11433 case LOGOFF:
11434 case LOGON:
11435 case NESTED:
11436 case NOAUDIT:
11437 case SCHEMA:
11438 case SERVERERROR:
11439 case SHUTDOWN:
11440 case STARTUP:
11441 case STATEMENT:
11442 case STATISTICS:
11443 case SUSPEND:
11444 case TRUNCATE:
11445 case WRAPPED:
11446 case LIBRARY:
11447 case NAME:
11448 case STRUCT:
11449 case CONTEXT:
11450 case PARAMETERS:
11451 case LENGTH:
11452 case TDO:
11453 case MAXLEN:
11454 case CHARSETID:
11455 case CHARSETFORM:
11456 case ACCEPT:
11457 case ACCESSIBLE:
11458 case COPY:
11459 case DEFINE:
11460 case DISCONNECT:
11461 case HOST:
11462 case PRINT:
11463 case QUIT:
11464 case REMARK:
11465 case UNDEFINE:
11466 case VARIABLE:
11467 case WHENEVER:
11468 case ATTACH:
11469 case CAST:
11470 case TREAT:
11471 case TRIM:
11472 case LEFT:
11473 case RIGHT:
11474 case BOTH:
11475 case EMPTY:
11476 case MULTISET:
11477 case SUBMULTISET:
11478 case LEADING:
11479 case TRAILING:
11480 case CHAR_CS:
11481 case NCHAR_CS:
11482 case DBTIMEZONE:
11483 case SESSIONTIMEZONE:
11484 case AUTHENTICATED:
11485 case LINK:
11486 case SHARED:
11487 case DIRECTORY:
11488 case USER:
11489 case IDENTIFIER:
11490 case UNSIGNED_NUMERIC_LITERAL:
11491 case CHARACTER_LITERAL:
11492 case STRING_LITERAL:
11493 case QUOTED_LITERAL:
11494 ;
11495 break;
11496 default:
11497 jj_la1[130] = jj_gen;
11498 break label_29;
11499 }
11500 }
11501 jj_consume_token(END);
11502 jj_consume_token(LOOP);
11503 switch (jj_nt.kind) {
11504 case IDENTIFIER:
11505 jj_consume_token(IDENTIFIER);
11506 break;
11507 default:
11508 jj_la1[131] = jj_gen;
11509 ;
11510 }
11511 jjtree.closeNodeScope(jjtn000, true);
11512 jjtc000 = false;
11513 {if (true) return jjtn000 ;}
11514 } catch (Throwable jjte000) {
11515 if (jjtc000) {
11516 jjtree.clearNodeScope(jjtn000);
11517 jjtc000 = false;
11518 } else {
11519 jjtree.popNode();
11520 }
11521 if (jjte000 instanceof RuntimeException) {
11522 {if (true) throw (RuntimeException)jjte000;}
11523 }
11524 if (jjte000 instanceof ParseException) {
11525 {if (true) throw (ParseException)jjte000;}
11526 }
11527 {if (true) throw (Error)jjte000;}
11528 } finally {
11529 if (jjtc000) {
11530 jjtree.closeNodeScope(jjtn000, true);
11531 }
11532 }
11533 throw new Error("Missing return statement in function");
11534 }
11535
11536
11537 final public ASTForStatement ForStatement() throws ParseException {
11538
11539 ASTForStatement jjtn000 = new ASTForStatement(this, JJTFORSTATEMENT);
11540 boolean jjtc000 = true;
11541 jjtree.openNodeScope(jjtn000);
11542 try {
11543 jj_consume_token(FOR);
11544 ForIndex();
11545 jj_consume_token(IN);
11546 switch (jj_nt.kind) {
11547 case REVERSE:
11548 jj_consume_token(REVERSE);
11549 break;
11550 default:
11551 jj_la1[132] = jj_gen;
11552 ;
11553 }
11554 Expression();
11555 switch (jj_nt.kind) {
11556 case 12:
11557 jj_consume_token(12);
11558 Expression();
11559 break;
11560 default:
11561 jj_la1[133] = jj_gen;
11562 ;
11563 }
11564 jj_consume_token(LOOP);
11565 label_30:
11566 while (true) {
11567 Statement();
11568 switch (jj_nt.kind) {
11569 case 5:
11570 case 16:
11571 case 17:
11572 case 21:
11573 case REPLACE:
11574 case DEFINER:
11575 case CURRENT_USER:
11576 case LANGUAGE:
11577 case ADD:
11578 case AGGREGATE:
11579 case ARRAY:
11580 case AT:
11581 case ATTRIBUTE:
11582 case AUTHID:
11583 case BEGIN:
11584 case BODY:
11585 case BULK:
11586 case BYTE:
11587 case CASCADE:
11588 case CASE:
11589 case CLOSE:
11590 case COALESCE:
11591 case COLLECT:
11592 case COLUMN:
11593 case COMMENT:
11594 case COMMIT:
11595 case CONSTRUCTOR:
11596 case CONTINUE:
11597 case CONVERT:
11598 case CURRENT:
11599 case CURSOR:
11600 case DATA:
11601 case DATE:
11602 case DAY:
11603 case DECLARE:
11604 case DELETE:
11605 case DISABLE:
11606 case EDITIONABLE:
11607 case ELEMENT:
11608 case ENABLE:
11609 case ESCAPE:
11610 case EXCEPT:
11611 case EXCEPTIONS:
11612 case EXECUTE:
11613 case EXIT:
11614 case EXTERNAL:
11615 case EXTENDS:
11616 case EXTRACT:
11617 case FALSE:
11618 case FETCH:
11619 case FINAL:
11620 case FOR:
11621 case FORALL:
11622 case FORCE:
11623 case FUNCTION:
11624 case GLOBAL:
11625 case GOTO:
11626 case HASH:
11627 case HEAP:
11628 case HOUR:
11629 case IF:
11630 case IMMEDIATE:
11631 case INDICES:
11632 case INDEXTYPE:
11633 case INDICATOR:
11634 case INSERT:
11635 case INSTANTIABLE:
11636 case INTERVAL:
11637 case INVALIDATE:
11638 case ISOLATION:
11639 case JAVA:
11640 case LEVEL:
11641 case LIMIT:
11642 case LOCK:
11643 case LOOP:
11644 case MAP:
11645 case MAX:
11646 case MEMBER:
11647 case MERGE:
11648 case MIN:
11649 case MINUTE:
11650 case MLSLABEL:
11651 case MODIFY:
11652 case MOD:
11653 case MONTH:
11654 case NATURAL:
11655 case NEW:
11656 case NEW_DOT:
11657 case NO:
11658 case NONEDITIONABLE:
11659 case NOT:
11660 case NULL:
11661 case NULLIF:
11662 case OBJECT:
11663 case OID:
11664 case OPAQUE:
11665 case OPEN:
11666 case OPERATOR:
11667 case ORGANIZATION:
11668 case OTHERS:
11669 case OVERRIDING:
11670 case PACKAGE:
11671 case PARTITION:
11672 case PIPE:
11673 case PRESERVE:
11674 case PRIVATE:
11675 case PROCEDURE:
11676 case RAISE:
11677 case RANGE:
11678 case RAW:
11679 case REAL:
11680 case RECORD:
11681 case REF:
11682 case RELEASE:
11683 case RELIES_ON:
11684 case RENAME:
11685 case RESULT:
11686 case RETURN:
11687 case RETURNING:
11688 case REVERSE:
11689 case ROLLBACK:
11690 case ROW:
11691 case ROWS:
11692 case ROWID:
11693 case ROWNUM:
11694 case SAVE:
11695 case SAVEPOINT:
11696 case SECOND:
11697 case SELECT:
11698 case SELF:
11699 case SET:
11700 case SPACE:
11701 case SQL:
11702 case SQLCODE:
11703 case SQLERRM:
11704 case STATIC:
11705 case SUBTYPE:
11706 case SUBSTITUTABLE:
11707 case SUCCESSFUL:
11708 case SYSDATE:
11709 case SYS_REFCURSOR:
11710 case TEMPORARY:
11711 case TIME:
11712 case TIMESTAMP:
11713 case TIMEZONE_REGION:
11714 case TIMEZONE_ABBR:
11715 case TIMEZONE_MINUTE:
11716 case TIMEZONE_HOUR:
11717 case TRANSACTION:
11718 case TRUE:
11719 case TYPE:
11720 case UNDER:
11721 case USING:
11722 case WHILE:
11723 case YES:
11724 case SHOW:
11725 case A:
11726 case UPDATE:
11727 case DOUBLE:
11728 case DEC:
11729 case PRECISION:
11730 case INT:
11731 case NUMERIC:
11732 case NCHAR:
11733 case NVARCHAR2:
11734 case STRING:
11735 case UROWID:
11736 case VARRAY:
11737 case VARYING:
11738 case BFILE:
11739 case BLOB:
11740 case CLOB:
11741 case NCLOB:
11742 case YEAR:
11743 case LOCAL:
11744 case WITH:
11745 case ZONE:
11746 case CHARACTER:
11747 case AFTER:
11748 case BEFORE:
11749 case OLD:
11750 case PARENT:
11751 case CC_IF:
11752 case CC_ERROR:
11753 case ANALYZE:
11754 case ASSOCIATE:
11755 case AUDIT:
11756 case COMPOUND:
11757 case DATABASE:
11758 case CALL:
11759 case DDL:
11760 case DISASSOCIATE:
11761 case EACH:
11762 case FOLLOWS:
11763 case LOGOFF:
11764 case LOGON:
11765 case NESTED:
11766 case NOAUDIT:
11767 case SCHEMA:
11768 case SERVERERROR:
11769 case SHUTDOWN:
11770 case STARTUP:
11771 case STATEMENT:
11772 case STATISTICS:
11773 case SUSPEND:
11774 case TRUNCATE:
11775 case WRAPPED:
11776 case LIBRARY:
11777 case NAME:
11778 case STRUCT:
11779 case CONTEXT:
11780 case PARAMETERS:
11781 case LENGTH:
11782 case TDO:
11783 case MAXLEN:
11784 case CHARSETID:
11785 case CHARSETFORM:
11786 case ACCEPT:
11787 case ACCESSIBLE:
11788 case COPY:
11789 case DEFINE:
11790 case DISCONNECT:
11791 case HOST:
11792 case PRINT:
11793 case QUIT:
11794 case REMARK:
11795 case UNDEFINE:
11796 case VARIABLE:
11797 case WHENEVER:
11798 case ATTACH:
11799 case CAST:
11800 case TREAT:
11801 case TRIM:
11802 case LEFT:
11803 case RIGHT:
11804 case BOTH:
11805 case EMPTY:
11806 case MULTISET:
11807 case SUBMULTISET:
11808 case LEADING:
11809 case TRAILING:
11810 case CHAR_CS:
11811 case NCHAR_CS:
11812 case DBTIMEZONE:
11813 case SESSIONTIMEZONE:
11814 case AUTHENTICATED:
11815 case LINK:
11816 case SHARED:
11817 case DIRECTORY:
11818 case USER:
11819 case IDENTIFIER:
11820 case UNSIGNED_NUMERIC_LITERAL:
11821 case CHARACTER_LITERAL:
11822 case STRING_LITERAL:
11823 case QUOTED_LITERAL:
11824 ;
11825 break;
11826 default:
11827 jj_la1[134] = jj_gen;
11828 break label_30;
11829 }
11830 }
11831 jj_consume_token(END);
11832 jj_consume_token(LOOP);
11833 switch (jj_nt.kind) {
11834 case IDENTIFIER:
11835 jj_consume_token(IDENTIFIER);
11836 break;
11837 default:
11838 jj_la1[135] = jj_gen;
11839 ;
11840 }
11841 jjtree.closeNodeScope(jjtn000, true);
11842 jjtc000 = false;
11843 {if (true) return jjtn000 ;}
11844 } catch (Throwable jjte000) {
11845 if (jjtc000) {
11846 jjtree.clearNodeScope(jjtn000);
11847 jjtc000 = false;
11848 } else {
11849 jjtree.popNode();
11850 }
11851 if (jjte000 instanceof RuntimeException) {
11852 {if (true) throw (RuntimeException)jjte000;}
11853 }
11854 if (jjte000 instanceof ParseException) {
11855 {if (true) throw (ParseException)jjte000;}
11856 }
11857 {if (true) throw (Error)jjte000;}
11858 } finally {
11859 if (jjtc000) {
11860 jjtree.closeNodeScope(jjtn000, true);
11861 }
11862 }
11863 throw new Error("Missing return statement in function");
11864 }
11865
11866 final public ASTWhileStatement WhileStatement() throws ParseException {
11867
11868 ASTWhileStatement jjtn000 = new ASTWhileStatement(this, JJTWHILESTATEMENT);
11869 boolean jjtc000 = true;
11870 jjtree.openNodeScope(jjtn000);
11871 try {
11872 jj_consume_token(WHILE);
11873 Expression();
11874 jj_consume_token(LOOP);
11875 label_31:
11876 while (true) {
11877 Statement();
11878 switch (jj_nt.kind) {
11879 case 5:
11880 case 16:
11881 case 17:
11882 case 21:
11883 case REPLACE:
11884 case DEFINER:
11885 case CURRENT_USER:
11886 case LANGUAGE:
11887 case ADD:
11888 case AGGREGATE:
11889 case ARRAY:
11890 case AT:
11891 case ATTRIBUTE:
11892 case AUTHID:
11893 case BEGIN:
11894 case BODY:
11895 case BULK:
11896 case BYTE:
11897 case CASCADE:
11898 case CASE:
11899 case CLOSE:
11900 case COALESCE:
11901 case COLLECT:
11902 case COLUMN:
11903 case COMMENT:
11904 case COMMIT:
11905 case CONSTRUCTOR:
11906 case CONTINUE:
11907 case CONVERT:
11908 case CURRENT:
11909 case CURSOR:
11910 case DATA:
11911 case DATE:
11912 case DAY:
11913 case DECLARE:
11914 case DELETE:
11915 case DISABLE:
11916 case EDITIONABLE:
11917 case ELEMENT:
11918 case ENABLE:
11919 case ESCAPE:
11920 case EXCEPT:
11921 case EXCEPTIONS:
11922 case EXECUTE:
11923 case EXIT:
11924 case EXTERNAL:
11925 case EXTENDS:
11926 case EXTRACT:
11927 case FALSE:
11928 case FETCH:
11929 case FINAL:
11930 case FOR:
11931 case FORALL:
11932 case FORCE:
11933 case FUNCTION:
11934 case GLOBAL:
11935 case GOTO:
11936 case HASH:
11937 case HEAP:
11938 case HOUR:
11939 case IF:
11940 case IMMEDIATE:
11941 case INDICES:
11942 case INDEXTYPE:
11943 case INDICATOR:
11944 case INSERT:
11945 case INSTANTIABLE:
11946 case INTERVAL:
11947 case INVALIDATE:
11948 case ISOLATION:
11949 case JAVA:
11950 case LEVEL:
11951 case LIMIT:
11952 case LOCK:
11953 case LOOP:
11954 case MAP:
11955 case MAX:
11956 case MEMBER:
11957 case MERGE:
11958 case MIN:
11959 case MINUTE:
11960 case MLSLABEL:
11961 case MODIFY:
11962 case MOD:
11963 case MONTH:
11964 case NATURAL:
11965 case NEW:
11966 case NEW_DOT:
11967 case NO:
11968 case NONEDITIONABLE:
11969 case NOT:
11970 case NULL:
11971 case NULLIF:
11972 case OBJECT:
11973 case OID:
11974 case OPAQUE:
11975 case OPEN:
11976 case OPERATOR:
11977 case ORGANIZATION:
11978 case OTHERS:
11979 case OVERRIDING:
11980 case PACKAGE:
11981 case PARTITION:
11982 case PIPE:
11983 case PRESERVE:
11984 case PRIVATE:
11985 case PROCEDURE:
11986 case RAISE:
11987 case RANGE:
11988 case RAW:
11989 case REAL:
11990 case RECORD:
11991 case REF:
11992 case RELEASE:
11993 case RELIES_ON:
11994 case RENAME:
11995 case RESULT:
11996 case RETURN:
11997 case RETURNING:
11998 case REVERSE:
11999 case ROLLBACK:
12000 case ROW:
12001 case ROWS:
12002 case ROWID:
12003 case ROWNUM:
12004 case SAVE:
12005 case SAVEPOINT:
12006 case SECOND:
12007 case SELECT:
12008 case SELF:
12009 case SET:
12010 case SPACE:
12011 case SQL:
12012 case SQLCODE:
12013 case SQLERRM:
12014 case STATIC:
12015 case SUBTYPE:
12016 case SUBSTITUTABLE:
12017 case SUCCESSFUL:
12018 case SYSDATE:
12019 case SYS_REFCURSOR:
12020 case TEMPORARY:
12021 case TIME:
12022 case TIMESTAMP:
12023 case TIMEZONE_REGION:
12024 case TIMEZONE_ABBR:
12025 case TIMEZONE_MINUTE:
12026 case TIMEZONE_HOUR:
12027 case TRANSACTION:
12028 case TRUE:
12029 case TYPE:
12030 case UNDER:
12031 case USING:
12032 case WHILE:
12033 case YES:
12034 case SHOW:
12035 case A:
12036 case UPDATE:
12037 case DOUBLE:
12038 case DEC:
12039 case PRECISION:
12040 case INT:
12041 case NUMERIC:
12042 case NCHAR:
12043 case NVARCHAR2:
12044 case STRING:
12045 case UROWID:
12046 case VARRAY:
12047 case VARYING:
12048 case BFILE:
12049 case BLOB:
12050 case CLOB:
12051 case NCLOB:
12052 case YEAR:
12053 case LOCAL:
12054 case WITH:
12055 case ZONE:
12056 case CHARACTER:
12057 case AFTER:
12058 case BEFORE:
12059 case OLD:
12060 case PARENT:
12061 case CC_IF:
12062 case CC_ERROR:
12063 case ANALYZE:
12064 case ASSOCIATE:
12065 case AUDIT:
12066 case COMPOUND:
12067 case DATABASE:
12068 case CALL:
12069 case DDL:
12070 case DISASSOCIATE:
12071 case EACH:
12072 case FOLLOWS:
12073 case LOGOFF:
12074 case LOGON:
12075 case NESTED:
12076 case NOAUDIT:
12077 case SCHEMA:
12078 case SERVERERROR:
12079 case SHUTDOWN:
12080 case STARTUP:
12081 case STATEMENT:
12082 case STATISTICS:
12083 case SUSPEND:
12084 case TRUNCATE:
12085 case WRAPPED:
12086 case LIBRARY:
12087 case NAME:
12088 case STRUCT:
12089 case CONTEXT:
12090 case PARAMETERS:
12091 case LENGTH:
12092 case TDO:
12093 case MAXLEN:
12094 case CHARSETID:
12095 case CHARSETFORM:
12096 case ACCEPT:
12097 case ACCESSIBLE:
12098 case COPY:
12099 case DEFINE:
12100 case DISCONNECT:
12101 case HOST:
12102 case PRINT:
12103 case QUIT:
12104 case REMARK:
12105 case UNDEFINE:
12106 case VARIABLE:
12107 case WHENEVER:
12108 case ATTACH:
12109 case CAST:
12110 case TREAT:
12111 case TRIM:
12112 case LEFT:
12113 case RIGHT:
12114 case BOTH:
12115 case EMPTY:
12116 case MULTISET:
12117 case SUBMULTISET:
12118 case LEADING:
12119 case TRAILING:
12120 case CHAR_CS:
12121 case NCHAR_CS:
12122 case DBTIMEZONE:
12123 case SESSIONTIMEZONE:
12124 case AUTHENTICATED:
12125 case LINK:
12126 case SHARED:
12127 case DIRECTORY:
12128 case USER:
12129 case IDENTIFIER:
12130 case UNSIGNED_NUMERIC_LITERAL:
12131 case CHARACTER_LITERAL:
12132 case STRING_LITERAL:
12133 case QUOTED_LITERAL:
12134 ;
12135 break;
12136 default:
12137 jj_la1[136] = jj_gen;
12138 break label_31;
12139 }
12140 }
12141 jj_consume_token(END);
12142 jj_consume_token(LOOP);
12143 switch (jj_nt.kind) {
12144 case IDENTIFIER:
12145 jj_consume_token(IDENTIFIER);
12146 break;
12147 default:
12148 jj_la1[137] = jj_gen;
12149 ;
12150 }
12151 jjtree.closeNodeScope(jjtn000, true);
12152 jjtc000 = false;
12153 {if (true) return jjtn000 ;}
12154 } catch (Throwable jjte000) {
12155 if (jjtc000) {
12156 jjtree.clearNodeScope(jjtn000);
12157 jjtc000 = false;
12158 } else {
12159 jjtree.popNode();
12160 }
12161 if (jjte000 instanceof RuntimeException) {
12162 {if (true) throw (RuntimeException)jjte000;}
12163 }
12164 if (jjte000 instanceof ParseException) {
12165 {if (true) throw (ParseException)jjte000;}
12166 }
12167 {if (true) throw (Error)jjte000;}
12168 } finally {
12169 if (jjtc000) {
12170 jjtree.closeNodeScope(jjtn000, true);
12171 }
12172 }
12173 throw new Error("Missing return statement in function");
12174 }
12175
12176 final public ASTIfStatement IfStatement() throws ParseException {
12177
12178 ASTIfStatement jjtn000 = new ASTIfStatement(this, JJTIFSTATEMENT);
12179 boolean jjtc000 = true;
12180 jjtree.openNodeScope(jjtn000);
12181 try {
12182 jj_consume_token(IF);
12183 Expression();
12184 jj_consume_token(THEN);
12185 label_32:
12186 while (true) {
12187 Statement();
12188 switch (jj_nt.kind) {
12189 case 5:
12190 case 16:
12191 case 17:
12192 case 21:
12193 case REPLACE:
12194 case DEFINER:
12195 case CURRENT_USER:
12196 case LANGUAGE:
12197 case ADD:
12198 case AGGREGATE:
12199 case ARRAY:
12200 case AT:
12201 case ATTRIBUTE:
12202 case AUTHID:
12203 case BEGIN:
12204 case BODY:
12205 case BULK:
12206 case BYTE:
12207 case CASCADE:
12208 case CASE:
12209 case CLOSE:
12210 case COALESCE:
12211 case COLLECT:
12212 case COLUMN:
12213 case COMMENT:
12214 case COMMIT:
12215 case CONSTRUCTOR:
12216 case CONTINUE:
12217 case CONVERT:
12218 case CURRENT:
12219 case CURSOR:
12220 case DATA:
12221 case DATE:
12222 case DAY:
12223 case DECLARE:
12224 case DELETE:
12225 case DISABLE:
12226 case EDITIONABLE:
12227 case ELEMENT:
12228 case ENABLE:
12229 case ESCAPE:
12230 case EXCEPT:
12231 case EXCEPTIONS:
12232 case EXECUTE:
12233 case EXIT:
12234 case EXTERNAL:
12235 case EXTENDS:
12236 case EXTRACT:
12237 case FALSE:
12238 case FETCH:
12239 case FINAL:
12240 case FOR:
12241 case FORALL:
12242 case FORCE:
12243 case FUNCTION:
12244 case GLOBAL:
12245 case GOTO:
12246 case HASH:
12247 case HEAP:
12248 case HOUR:
12249 case IF:
12250 case IMMEDIATE:
12251 case INDICES:
12252 case INDEXTYPE:
12253 case INDICATOR:
12254 case INSERT:
12255 case INSTANTIABLE:
12256 case INTERVAL:
12257 case INVALIDATE:
12258 case ISOLATION:
12259 case JAVA:
12260 case LEVEL:
12261 case LIMIT:
12262 case LOCK:
12263 case LOOP:
12264 case MAP:
12265 case MAX:
12266 case MEMBER:
12267 case MERGE:
12268 case MIN:
12269 case MINUTE:
12270 case MLSLABEL:
12271 case MODIFY:
12272 case MOD:
12273 case MONTH:
12274 case NATURAL:
12275 case NEW:
12276 case NEW_DOT:
12277 case NO:
12278 case NONEDITIONABLE:
12279 case NOT:
12280 case NULL:
12281 case NULLIF:
12282 case OBJECT:
12283 case OID:
12284 case OPAQUE:
12285 case OPEN:
12286 case OPERATOR:
12287 case ORGANIZATION:
12288 case OTHERS:
12289 case OVERRIDING:
12290 case PACKAGE:
12291 case PARTITION:
12292 case PIPE:
12293 case PRESERVE:
12294 case PRIVATE:
12295 case PROCEDURE:
12296 case RAISE:
12297 case RANGE:
12298 case RAW:
12299 case REAL:
12300 case RECORD:
12301 case REF:
12302 case RELEASE:
12303 case RELIES_ON:
12304 case RENAME:
12305 case RESULT:
12306 case RETURN:
12307 case RETURNING:
12308 case REVERSE:
12309 case ROLLBACK:
12310 case ROW:
12311 case ROWS:
12312 case ROWID:
12313 case ROWNUM:
12314 case SAVE:
12315 case SAVEPOINT:
12316 case SECOND:
12317 case SELECT:
12318 case SELF:
12319 case SET:
12320 case SPACE:
12321 case SQL:
12322 case SQLCODE:
12323 case SQLERRM:
12324 case STATIC:
12325 case SUBTYPE:
12326 case SUBSTITUTABLE:
12327 case SUCCESSFUL:
12328 case SYSDATE:
12329 case SYS_REFCURSOR:
12330 case TEMPORARY:
12331 case TIME:
12332 case TIMESTAMP:
12333 case TIMEZONE_REGION:
12334 case TIMEZONE_ABBR:
12335 case TIMEZONE_MINUTE:
12336 case TIMEZONE_HOUR:
12337 case TRANSACTION:
12338 case TRUE:
12339 case TYPE:
12340 case UNDER:
12341 case USING:
12342 case WHILE:
12343 case YES:
12344 case SHOW:
12345 case A:
12346 case UPDATE:
12347 case DOUBLE:
12348 case DEC:
12349 case PRECISION:
12350 case INT:
12351 case NUMERIC:
12352 case NCHAR:
12353 case NVARCHAR2:
12354 case STRING:
12355 case UROWID:
12356 case VARRAY:
12357 case VARYING:
12358 case BFILE:
12359 case BLOB:
12360 case CLOB:
12361 case NCLOB:
12362 case YEAR:
12363 case LOCAL:
12364 case WITH:
12365 case ZONE:
12366 case CHARACTER:
12367 case AFTER:
12368 case BEFORE:
12369 case OLD:
12370 case PARENT:
12371 case CC_IF:
12372 case CC_ERROR:
12373 case ANALYZE:
12374 case ASSOCIATE:
12375 case AUDIT:
12376 case COMPOUND:
12377 case DATABASE:
12378 case CALL:
12379 case DDL:
12380 case DISASSOCIATE:
12381 case EACH:
12382 case FOLLOWS:
12383 case LOGOFF:
12384 case LOGON:
12385 case NESTED:
12386 case NOAUDIT:
12387 case SCHEMA:
12388 case SERVERERROR:
12389 case SHUTDOWN:
12390 case STARTUP:
12391 case STATEMENT:
12392 case STATISTICS:
12393 case SUSPEND:
12394 case TRUNCATE:
12395 case WRAPPED:
12396 case LIBRARY:
12397 case NAME:
12398 case STRUCT:
12399 case CONTEXT:
12400 case PARAMETERS:
12401 case LENGTH:
12402 case TDO:
12403 case MAXLEN:
12404 case CHARSETID:
12405 case CHARSETFORM:
12406 case ACCEPT:
12407 case ACCESSIBLE:
12408 case COPY:
12409 case DEFINE:
12410 case DISCONNECT:
12411 case HOST:
12412 case PRINT:
12413 case QUIT:
12414 case REMARK:
12415 case UNDEFINE:
12416 case VARIABLE:
12417 case WHENEVER:
12418 case ATTACH:
12419 case CAST:
12420 case TREAT:
12421 case TRIM:
12422 case LEFT:
12423 case RIGHT:
12424 case BOTH:
12425 case EMPTY:
12426 case MULTISET:
12427 case SUBMULTISET:
12428 case LEADING:
12429 case TRAILING:
12430 case CHAR_CS:
12431 case NCHAR_CS:
12432 case DBTIMEZONE:
12433 case SESSIONTIMEZONE:
12434 case AUTHENTICATED:
12435 case LINK:
12436 case SHARED:
12437 case DIRECTORY:
12438 case USER:
12439 case IDENTIFIER:
12440 case UNSIGNED_NUMERIC_LITERAL:
12441 case CHARACTER_LITERAL:
12442 case STRING_LITERAL:
12443 case QUOTED_LITERAL:
12444 ;
12445 break;
12446 default:
12447 jj_la1[138] = jj_gen;
12448 break label_32;
12449 }
12450 }
12451 label_33:
12452 while (true) {
12453 switch (jj_nt.kind) {
12454 case ELSIF:
12455 ;
12456 break;
12457 default:
12458 jj_la1[139] = jj_gen;
12459 break label_33;
12460 }
12461 ElsifClause();
12462 jjtn000.setHasElse();
12463 }
12464 switch (jj_nt.kind) {
12465 case ELSE:
12466 ElseClause();
12467 jjtn000.setHasElse();
12468 break;
12469 default:
12470 jj_la1[140] = jj_gen;
12471 ;
12472 }
12473 jj_consume_token(END);
12474 jj_consume_token(IF);
12475 jjtree.closeNodeScope(jjtn000, true);
12476 jjtc000 = false;
12477 {if (true) return jjtn000 ;}
12478 } catch (Throwable jjte000) {
12479 if (jjtc000) {
12480 jjtree.clearNodeScope(jjtn000);
12481 jjtc000 = false;
12482 } else {
12483 jjtree.popNode();
12484 }
12485 if (jjte000 instanceof RuntimeException) {
12486 {if (true) throw (RuntimeException)jjte000;}
12487 }
12488 if (jjte000 instanceof ParseException) {
12489 {if (true) throw (ParseException)jjte000;}
12490 }
12491 {if (true) throw (Error)jjte000;}
12492 } finally {
12493 if (jjtc000) {
12494 jjtree.closeNodeScope(jjtn000, true);
12495 }
12496 }
12497 throw new Error("Missing return statement in function");
12498 }
12499
12500
12501
12502
12503
12504 final public ASTForIndex ForIndex() throws ParseException {
12505
12506 ASTForIndex jjtn000 = new ASTForIndex(this, JJTFORINDEX);
12507 boolean jjtc000 = true;
12508 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
12509 try {
12510 simpleNode = ID();
12511 jjtree.closeNodeScope(jjtn000, true);
12512 jjtc000 = false;
12513 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
12514 } catch (Throwable jjte000) {
12515 if (jjtc000) {
12516 jjtree.clearNodeScope(jjtn000);
12517 jjtc000 = false;
12518 } else {
12519 jjtree.popNode();
12520 }
12521 if (jjte000 instanceof RuntimeException) {
12522 {if (true) throw (RuntimeException)jjte000;}
12523 }
12524 if (jjte000 instanceof ParseException) {
12525 {if (true) throw (ParseException)jjte000;}
12526 }
12527 {if (true) throw (Error)jjte000;}
12528 } finally {
12529 if (jjtc000) {
12530 jjtree.closeNodeScope(jjtn000, true);
12531 }
12532 }
12533 throw new Error("Missing return statement in function");
12534 }
12535
12536
12537
12538
12539 final public ASTForAllIndex ForAllIndex() throws ParseException {
12540
12541 ASTForAllIndex jjtn000 = new ASTForAllIndex(this, JJTFORALLINDEX);
12542 boolean jjtc000 = true;
12543 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
12544 try {
12545 simpleNode = ID();
12546 jjtree.closeNodeScope(jjtn000, true);
12547 jjtc000 = false;
12548 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
12549 } catch (Throwable jjte000) {
12550 if (jjtc000) {
12551 jjtree.clearNodeScope(jjtn000);
12552 jjtc000 = false;
12553 } else {
12554 jjtree.popNode();
12555 }
12556 if (jjte000 instanceof RuntimeException) {
12557 {if (true) throw (RuntimeException)jjte000;}
12558 }
12559 if (jjte000 instanceof ParseException) {
12560 {if (true) throw (ParseException)jjte000;}
12561 }
12562 {if (true) throw (Error)jjte000;}
12563 } finally {
12564 if (jjtc000) {
12565 jjtree.closeNodeScope(jjtn000, true);
12566 }
12567 }
12568 throw new Error("Missing return statement in function");
12569 }
12570
12571 final public ASTForAllStatement ForAllStatement() throws ParseException {
12572
12573 ASTForAllStatement jjtn000 = new ASTForAllStatement(this, JJTFORALLSTATEMENT);
12574 boolean jjtc000 = true;
12575 jjtree.openNodeScope(jjtn000);
12576 try {
12577 jj_consume_token(FORALL);
12578 ForAllIndex();
12579 jj_consume_token(IN);
12580 switch (jj_nt.kind) {
12581 case INDICES:
12582 case VALUES:
12583 switch (jj_nt.kind) {
12584 case INDICES:
12585 jj_consume_token(INDICES);
12586 break;
12587 case VALUES:
12588 jj_consume_token(VALUES);
12589 break;
12590 default:
12591 jj_la1[141] = jj_gen;
12592 jj_consume_token(-1);
12593 throw new ParseException();
12594 }
12595 jj_consume_token(OF);
12596 Expression();
12597 break;
12598 case 5:
12599 case 16:
12600 case 17:
12601 case REPLACE:
12602 case DEFINER:
12603 case CURRENT_USER:
12604 case LANGUAGE:
12605 case ADD:
12606 case AGGREGATE:
12607 case ARRAY:
12608 case AT:
12609 case ATTRIBUTE:
12610 case AUTHID:
12611 case BODY:
12612 case BULK:
12613 case BYTE:
12614 case CASCADE:
12615 case CASE:
12616 case CLOSE:
12617 case COALESCE:
12618 case COLLECT:
12619 case COLUMN:
12620 case COMMENT:
12621 case COMMIT:
12622 case CONSTRUCTOR:
12623 case CONTINUE:
12624 case CONVERT:
12625 case CURRENT:
12626 case CURSOR:
12627 case DATA:
12628 case DATE:
12629 case DAY:
12630 case DISABLE:
12631 case EDITIONABLE:
12632 case ELEMENT:
12633 case ENABLE:
12634 case ESCAPE:
12635 case EXCEPT:
12636 case EXCEPTIONS:
12637 case EXIT:
12638 case EXTERNAL:
12639 case EXTENDS:
12640 case EXTRACT:
12641 case FALSE:
12642 case FINAL:
12643 case FORCE:
12644 case FUNCTION:
12645 case GLOBAL:
12646 case HASH:
12647 case HEAP:
12648 case HOUR:
12649 case IMMEDIATE:
12650 case INDEXTYPE:
12651 case INDICATOR:
12652 case INSTANTIABLE:
12653 case INTERVAL:
12654 case INVALIDATE:
12655 case ISOLATION:
12656 case JAVA:
12657 case LEVEL:
12658 case LIMIT:
12659 case LOOP:
12660 case MAP:
12661 case MAX:
12662 case MEMBER:
12663 case MERGE:
12664 case MIN:
12665 case MINUTE:
12666 case MLSLABEL:
12667 case MODIFY:
12668 case MOD:
12669 case MONTH:
12670 case NATURAL:
12671 case NEW:
12672 case NEW_DOT:
12673 case NO:
12674 case NONEDITIONABLE:
12675 case NOT:
12676 case NULL:
12677 case NULLIF:
12678 case OBJECT:
12679 case OID:
12680 case OPAQUE:
12681 case OPEN:
12682 case OPERATOR:
12683 case ORGANIZATION:
12684 case OTHERS:
12685 case OVERRIDING:
12686 case PACKAGE:
12687 case PARTITION:
12688 case PRESERVE:
12689 case PRIVATE:
12690 case PROCEDURE:
12691 case RANGE:
12692 case RAW:
12693 case REAL:
12694 case RECORD:
12695 case REF:
12696 case RELEASE:
12697 case RELIES_ON:
12698 case RENAME:
12699 case RESULT:
12700 case RETURN:
12701 case RETURNING:
12702 case REVERSE:
12703 case ROLLBACK:
12704 case ROW:
12705 case ROWS:
12706 case ROWID:
12707 case ROWNUM:
12708 case SAVE:
12709 case SAVEPOINT:
12710 case SECOND:
12711 case SELECT:
12712 case SELF:
12713 case SET:
12714 case SPACE:
12715 case SQL:
12716 case SQLCODE:
12717 case SQLERRM:
12718 case STATIC:
12719 case SUBTYPE:
12720 case SUBSTITUTABLE:
12721 case SUCCESSFUL:
12722 case SYSDATE:
12723 case SYS_REFCURSOR:
12724 case TEMPORARY:
12725 case TIME:
12726 case TIMESTAMP:
12727 case TIMEZONE_REGION:
12728 case TIMEZONE_ABBR:
12729 case TIMEZONE_MINUTE:
12730 case TIMEZONE_HOUR:
12731 case TRANSACTION:
12732 case TRUE:
12733 case TYPE:
12734 case UNDER:
12735 case USING:
12736 case YES:
12737 case SHOW:
12738 case A:
12739 case DOUBLE:
12740 case DEC:
12741 case PRECISION:
12742 case INT:
12743 case NUMERIC:
12744 case NCHAR:
12745 case NVARCHAR2:
12746 case STRING:
12747 case UROWID:
12748 case VARRAY:
12749 case VARYING:
12750 case BFILE:
12751 case BLOB:
12752 case CLOB:
12753 case NCLOB:
12754 case YEAR:
12755 case LOCAL:
12756 case WITH:
12757 case ZONE:
12758 case CHARACTER:
12759 case AFTER:
12760 case BEFORE:
12761 case OLD:
12762 case PARENT:
12763 case CC_IF:
12764 case ANALYZE:
12765 case ASSOCIATE:
12766 case AUDIT:
12767 case COMPOUND:
12768 case DATABASE:
12769 case CALL:
12770 case DDL:
12771 case DISASSOCIATE:
12772 case EACH:
12773 case FOLLOWS:
12774 case LOGOFF:
12775 case LOGON:
12776 case NESTED:
12777 case NOAUDIT:
12778 case SCHEMA:
12779 case SERVERERROR:
12780 case SHUTDOWN:
12781 case STARTUP:
12782 case STATEMENT:
12783 case STATISTICS:
12784 case SUSPEND:
12785 case TRUNCATE:
12786 case WRAPPED:
12787 case LIBRARY:
12788 case NAME:
12789 case STRUCT:
12790 case CONTEXT:
12791 case PARAMETERS:
12792 case LENGTH:
12793 case TDO:
12794 case MAXLEN:
12795 case CHARSETID:
12796 case CHARSETFORM:
12797 case ACCEPT:
12798 case ACCESSIBLE:
12799 case COPY:
12800 case DEFINE:
12801 case DISCONNECT:
12802 case HOST:
12803 case PRINT:
12804 case QUIT:
12805 case REMARK:
12806 case UNDEFINE:
12807 case VARIABLE:
12808 case WHENEVER:
12809 case ATTACH:
12810 case CAST:
12811 case TREAT:
12812 case TRIM:
12813 case LEFT:
12814 case RIGHT:
12815 case BOTH:
12816 case EMPTY:
12817 case MULTISET:
12818 case SUBMULTISET:
12819 case LEADING:
12820 case TRAILING:
12821 case CHAR_CS:
12822 case NCHAR_CS:
12823 case DBTIMEZONE:
12824 case SESSIONTIMEZONE:
12825 case AUTHENTICATED:
12826 case LINK:
12827 case SHARED:
12828 case DIRECTORY:
12829 case USER:
12830 case IDENTIFIER:
12831 case UNSIGNED_NUMERIC_LITERAL:
12832 case CHARACTER_LITERAL:
12833 case STRING_LITERAL:
12834 case QUOTED_LITERAL:
12835 Expression();
12836 switch (jj_nt.kind) {
12837 case 12:
12838 jj_consume_token(12);
12839 Expression();
12840 break;
12841 default:
12842 jj_la1[142] = jj_gen;
12843 ;
12844 }
12845 break;
12846 default:
12847 jj_la1[143] = jj_gen;
12848 jj_consume_token(-1);
12849 throw new ParseException();
12850 }
12851 switch (jj_nt.kind) {
12852 case SAVE:
12853 jj_consume_token(SAVE);
12854 jj_consume_token(EXCEPTIONS);
12855 break;
12856 default:
12857 jj_la1[144] = jj_gen;
12858 ;
12859 }
12860 SqlStatement(null,";");
12861 jjtree.closeNodeScope(jjtn000, true);
12862 jjtc000 = false;
12863 {if (true) return jjtn000 ;}
12864 } catch (Throwable jjte000) {
12865 if (jjtc000) {
12866 jjtree.clearNodeScope(jjtn000);
12867 jjtc000 = false;
12868 } else {
12869 jjtree.popNode();
12870 }
12871 if (jjte000 instanceof RuntimeException) {
12872 {if (true) throw (RuntimeException)jjte000;}
12873 }
12874 if (jjte000 instanceof ParseException) {
12875 {if (true) throw (ParseException)jjte000;}
12876 }
12877 {if (true) throw (Error)jjte000;}
12878 } finally {
12879 if (jjtc000) {
12880 jjtree.closeNodeScope(jjtn000, true);
12881 }
12882 }
12883 throw new Error("Missing return statement in function");
12884 }
12885
12886 final public ASTGotoStatement GotoStatement() throws ParseException {
12887
12888 ASTGotoStatement jjtn000 = new ASTGotoStatement(this, JJTGOTOSTATEMENT);
12889 boolean jjtc000 = true;
12890 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
12891 try {
12892 jj_consume_token(GOTO);
12893 label = QualifiedName();
12894 jjtree.closeNodeScope(jjtn000, true);
12895 jjtc000 = false;
12896 jjtn000.setImage(label.getImage()) ; {if (true) return jjtn000 ;}
12897 } catch (Throwable jjte000) {
12898 if (jjtc000) {
12899 jjtree.clearNodeScope(jjtn000);
12900 jjtc000 = false;
12901 } else {
12902 jjtree.popNode();
12903 }
12904 if (jjte000 instanceof RuntimeException) {
12905 {if (true) throw (RuntimeException)jjte000;}
12906 }
12907 if (jjte000 instanceof ParseException) {
12908 {if (true) throw (ParseException)jjte000;}
12909 }
12910 {if (true) throw (Error)jjte000;}
12911 } finally {
12912 if (jjtc000) {
12913 jjtree.closeNodeScope(jjtn000, true);
12914 }
12915 }
12916 throw new Error("Missing return statement in function");
12917 }
12918
12919 final public ASTReturnStatement ReturnStatement() throws ParseException {
12920
12921 ASTReturnStatement jjtn000 = new ASTReturnStatement(this, JJTRETURNSTATEMENT);
12922 boolean jjtc000 = true;
12923 jjtree.openNodeScope(jjtn000);
12924 try {
12925 jj_consume_token(RETURN);
12926 switch (jj_nt.kind) {
12927 case 5:
12928 case 16:
12929 case 17:
12930 case REPLACE:
12931 case DEFINER:
12932 case CURRENT_USER:
12933 case LANGUAGE:
12934 case ADD:
12935 case AGGREGATE:
12936 case ARRAY:
12937 case AT:
12938 case ATTRIBUTE:
12939 case AUTHID:
12940 case BODY:
12941 case BULK:
12942 case BYTE:
12943 case CASCADE:
12944 case CASE:
12945 case CLOSE:
12946 case COALESCE:
12947 case COLLECT:
12948 case COLUMN:
12949 case COMMENT:
12950 case COMMIT:
12951 case CONSTRUCTOR:
12952 case CONTINUE:
12953 case CONVERT:
12954 case CURRENT:
12955 case CURSOR:
12956 case DATA:
12957 case DATE:
12958 case DAY:
12959 case DISABLE:
12960 case EDITIONABLE:
12961 case ELEMENT:
12962 case ENABLE:
12963 case ESCAPE:
12964 case EXCEPT:
12965 case EXCEPTIONS:
12966 case EXIT:
12967 case EXTERNAL:
12968 case EXTENDS:
12969 case EXTRACT:
12970 case FALSE:
12971 case FINAL:
12972 case FORCE:
12973 case FUNCTION:
12974 case GLOBAL:
12975 case HASH:
12976 case HEAP:
12977 case HOUR:
12978 case IMMEDIATE:
12979 case INDICES:
12980 case INDEXTYPE:
12981 case INDICATOR:
12982 case INSTANTIABLE:
12983 case INTERVAL:
12984 case INVALIDATE:
12985 case ISOLATION:
12986 case JAVA:
12987 case LEVEL:
12988 case LIMIT:
12989 case LOOP:
12990 case MAP:
12991 case MAX:
12992 case MEMBER:
12993 case MERGE:
12994 case MIN:
12995 case MINUTE:
12996 case MLSLABEL:
12997 case MODIFY:
12998 case MOD:
12999 case MONTH:
13000 case NATURAL:
13001 case NEW:
13002 case NEW_DOT:
13003 case NO:
13004 case NONEDITIONABLE:
13005 case NOT:
13006 case NULL:
13007 case NULLIF:
13008 case OBJECT:
13009 case OID:
13010 case OPAQUE:
13011 case OPEN:
13012 case OPERATOR:
13013 case ORGANIZATION:
13014 case OTHERS:
13015 case OVERRIDING:
13016 case PACKAGE:
13017 case PARTITION:
13018 case PRESERVE:
13019 case PRIVATE:
13020 case PROCEDURE:
13021 case RANGE:
13022 case RAW:
13023 case REAL:
13024 case RECORD:
13025 case REF:
13026 case RELEASE:
13027 case RELIES_ON:
13028 case RENAME:
13029 case RESULT:
13030 case RETURN:
13031 case RETURNING:
13032 case REVERSE:
13033 case ROLLBACK:
13034 case ROW:
13035 case ROWS:
13036 case ROWID:
13037 case ROWNUM:
13038 case SAVE:
13039 case SAVEPOINT:
13040 case SECOND:
13041 case SELECT:
13042 case SELF:
13043 case SET:
13044 case SPACE:
13045 case SQL:
13046 case SQLCODE:
13047 case SQLERRM:
13048 case STATIC:
13049 case SUBTYPE:
13050 case SUBSTITUTABLE:
13051 case SUCCESSFUL:
13052 case SYSDATE:
13053 case SYS_REFCURSOR:
13054 case TEMPORARY:
13055 case TIME:
13056 case TIMESTAMP:
13057 case TIMEZONE_REGION:
13058 case TIMEZONE_ABBR:
13059 case TIMEZONE_MINUTE:
13060 case TIMEZONE_HOUR:
13061 case TRANSACTION:
13062 case TRUE:
13063 case TYPE:
13064 case UNDER:
13065 case USING:
13066 case YES:
13067 case SHOW:
13068 case A:
13069 case DOUBLE:
13070 case DEC:
13071 case PRECISION:
13072 case INT:
13073 case NUMERIC:
13074 case NCHAR:
13075 case NVARCHAR2:
13076 case STRING:
13077 case UROWID:
13078 case VARRAY:
13079 case VARYING:
13080 case BFILE:
13081 case BLOB:
13082 case CLOB:
13083 case NCLOB:
13084 case YEAR:
13085 case LOCAL:
13086 case WITH:
13087 case ZONE:
13088 case CHARACTER:
13089 case AFTER:
13090 case BEFORE:
13091 case OLD:
13092 case PARENT:
13093 case CC_IF:
13094 case ANALYZE:
13095 case ASSOCIATE:
13096 case AUDIT:
13097 case COMPOUND:
13098 case DATABASE:
13099 case CALL:
13100 case DDL:
13101 case DISASSOCIATE:
13102 case EACH:
13103 case FOLLOWS:
13104 case LOGOFF:
13105 case LOGON:
13106 case NESTED:
13107 case NOAUDIT:
13108 case SCHEMA:
13109 case SERVERERROR:
13110 case SHUTDOWN:
13111 case STARTUP:
13112 case STATEMENT:
13113 case STATISTICS:
13114 case SUSPEND:
13115 case TRUNCATE:
13116 case WRAPPED:
13117 case LIBRARY:
13118 case NAME:
13119 case STRUCT:
13120 case CONTEXT:
13121 case PARAMETERS:
13122 case LENGTH:
13123 case TDO:
13124 case MAXLEN:
13125 case CHARSETID:
13126 case CHARSETFORM:
13127 case ACCEPT:
13128 case ACCESSIBLE:
13129 case COPY:
13130 case DEFINE:
13131 case DISCONNECT:
13132 case HOST:
13133 case PRINT:
13134 case QUIT:
13135 case REMARK:
13136 case UNDEFINE:
13137 case VARIABLE:
13138 case WHENEVER:
13139 case ATTACH:
13140 case CAST:
13141 case TREAT:
13142 case TRIM:
13143 case LEFT:
13144 case RIGHT:
13145 case BOTH:
13146 case EMPTY:
13147 case MULTISET:
13148 case SUBMULTISET:
13149 case LEADING:
13150 case TRAILING:
13151 case CHAR_CS:
13152 case NCHAR_CS:
13153 case DBTIMEZONE:
13154 case SESSIONTIMEZONE:
13155 case AUTHENTICATED:
13156 case LINK:
13157 case SHARED:
13158 case DIRECTORY:
13159 case USER:
13160 case IDENTIFIER:
13161 case UNSIGNED_NUMERIC_LITERAL:
13162 case CHARACTER_LITERAL:
13163 case STRING_LITERAL:
13164 case QUOTED_LITERAL:
13165 Expression();
13166 break;
13167 default:
13168 jj_la1[145] = jj_gen;
13169 ;
13170 }
13171 jjtree.closeNodeScope(jjtn000, true);
13172 jjtc000 = false;
13173 {if (true) return jjtn000 ;}
13174 } catch (Throwable jjte000) {
13175 if (jjtc000) {
13176 jjtree.clearNodeScope(jjtn000);
13177 jjtc000 = false;
13178 } else {
13179 jjtree.popNode();
13180 }
13181 if (jjte000 instanceof RuntimeException) {
13182 {if (true) throw (RuntimeException)jjte000;}
13183 }
13184 if (jjte000 instanceof ParseException) {
13185 {if (true) throw (ParseException)jjte000;}
13186 }
13187 {if (true) throw (Error)jjte000;}
13188 } finally {
13189 if (jjtc000) {
13190 jjtree.closeNodeScope(jjtn000, true);
13191 }
13192 }
13193 throw new Error("Missing return statement in function");
13194 }
13195
13196 final public ASTContinueStatement ContinueStatement() throws ParseException {
13197
13198 ASTContinueStatement jjtn000 = new ASTContinueStatement(this, JJTCONTINUESTATEMENT);
13199 boolean jjtc000 = true;
13200 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13201 try {
13202 jj_consume_token(CONTINUE);
13203 switch (jj_nt.kind) {
13204 case REPLACE:
13205 case DEFINER:
13206 case CURRENT_USER:
13207 case LANGUAGE:
13208 case ADD:
13209 case AGGREGATE:
13210 case ARRAY:
13211 case AT:
13212 case ATTRIBUTE:
13213 case AUTHID:
13214 case BODY:
13215 case BULK:
13216 case BYTE:
13217 case CASCADE:
13218 case CLOSE:
13219 case COALESCE:
13220 case COLLECT:
13221 case COLUMN:
13222 case COMMENT:
13223 case COMMIT:
13224 case CONSTRUCTOR:
13225 case CONTINUE:
13226 case CONVERT:
13227 case CURRENT:
13228 case CURSOR:
13229 case DATA:
13230 case DAY:
13231 case DISABLE:
13232 case EDITIONABLE:
13233 case ELEMENT:
13234 case ENABLE:
13235 case ESCAPE:
13236 case EXCEPT:
13237 case EXCEPTIONS:
13238 case EXIT:
13239 case EXTERNAL:
13240 case EXTENDS:
13241 case EXTRACT:
13242 case FALSE:
13243 case FINAL:
13244 case FORCE:
13245 case FUNCTION:
13246 case GLOBAL:
13247 case HASH:
13248 case HEAP:
13249 case HOUR:
13250 case IMMEDIATE:
13251 case INDICES:
13252 case INDEXTYPE:
13253 case INDICATOR:
13254 case INSTANTIABLE:
13255 case INTERVAL:
13256 case INVALIDATE:
13257 case ISOLATION:
13258 case JAVA:
13259 case LEVEL:
13260 case LIMIT:
13261 case LOOP:
13262 case MAP:
13263 case MAX:
13264 case MEMBER:
13265 case MERGE:
13266 case MIN:
13267 case MINUTE:
13268 case MLSLABEL:
13269 case MODIFY:
13270 case MOD:
13271 case MONTH:
13272 case NATURAL:
13273 case NEW:
13274 case NO:
13275 case NONEDITIONABLE:
13276 case NULLIF:
13277 case OBJECT:
13278 case OID:
13279 case OPAQUE:
13280 case OPEN:
13281 case OPERATOR:
13282 case ORGANIZATION:
13283 case OTHERS:
13284 case OVERRIDING:
13285 case PACKAGE:
13286 case PARTITION:
13287 case PRESERVE:
13288 case PRIVATE:
13289 case PROCEDURE:
13290 case RANGE:
13291 case RAW:
13292 case REAL:
13293 case RECORD:
13294 case REF:
13295 case RELEASE:
13296 case RELIES_ON:
13297 case RENAME:
13298 case RESULT:
13299 case RETURN:
13300 case RETURNING:
13301 case REVERSE:
13302 case ROLLBACK:
13303 case ROW:
13304 case ROWS:
13305 case ROWID:
13306 case ROWNUM:
13307 case SAVE:
13308 case SAVEPOINT:
13309 case SECOND:
13310 case SELF:
13311 case SET:
13312 case SPACE:
13313 case SQL:
13314 case SQLCODE:
13315 case SQLERRM:
13316 case STATIC:
13317 case SUBTYPE:
13318 case SUBSTITUTABLE:
13319 case SUCCESSFUL:
13320 case SYSDATE:
13321 case SYS_REFCURSOR:
13322 case TEMPORARY:
13323 case TIME:
13324 case TIMESTAMP:
13325 case TIMEZONE_REGION:
13326 case TIMEZONE_ABBR:
13327 case TIMEZONE_MINUTE:
13328 case TIMEZONE_HOUR:
13329 case TRANSACTION:
13330 case TRUE:
13331 case TYPE:
13332 case UNDER:
13333 case USING:
13334 case YES:
13335 case SHOW:
13336 case A:
13337 case DOUBLE:
13338 case DEC:
13339 case PRECISION:
13340 case INT:
13341 case NUMERIC:
13342 case NCHAR:
13343 case NVARCHAR2:
13344 case STRING:
13345 case UROWID:
13346 case VARRAY:
13347 case VARYING:
13348 case BFILE:
13349 case BLOB:
13350 case CLOB:
13351 case NCLOB:
13352 case YEAR:
13353 case LOCAL:
13354 case ZONE:
13355 case CHARACTER:
13356 case AFTER:
13357 case BEFORE:
13358 case OLD:
13359 case PARENT:
13360 case ANALYZE:
13361 case ASSOCIATE:
13362 case AUDIT:
13363 case COMPOUND:
13364 case DATABASE:
13365 case CALL:
13366 case DDL:
13367 case DISASSOCIATE:
13368 case EACH:
13369 case FOLLOWS:
13370 case LOGOFF:
13371 case LOGON:
13372 case NESTED:
13373 case NOAUDIT:
13374 case SCHEMA:
13375 case SERVERERROR:
13376 case SHUTDOWN:
13377 case STARTUP:
13378 case STATEMENT:
13379 case STATISTICS:
13380 case SUSPEND:
13381 case TRUNCATE:
13382 case WRAPPED:
13383 case LIBRARY:
13384 case NAME:
13385 case STRUCT:
13386 case CONTEXT:
13387 case PARAMETERS:
13388 case LENGTH:
13389 case TDO:
13390 case MAXLEN:
13391 case CHARSETID:
13392 case CHARSETFORM:
13393 case ACCEPT:
13394 case ACCESSIBLE:
13395 case COPY:
13396 case DEFINE:
13397 case DISCONNECT:
13398 case HOST:
13399 case PRINT:
13400 case QUIT:
13401 case REMARK:
13402 case UNDEFINE:
13403 case VARIABLE:
13404 case WHENEVER:
13405 case ATTACH:
13406 case CAST:
13407 case TREAT:
13408 case TRIM:
13409 case LEFT:
13410 case RIGHT:
13411 case BOTH:
13412 case EMPTY:
13413 case MULTISET:
13414 case SUBMULTISET:
13415 case LEADING:
13416 case TRAILING:
13417 case CHAR_CS:
13418 case NCHAR_CS:
13419 case DBTIMEZONE:
13420 case SESSIONTIMEZONE:
13421 case AUTHENTICATED:
13422 case LINK:
13423 case SHARED:
13424 case DIRECTORY:
13425 case USER:
13426 case IDENTIFIER:
13427 case QUOTED_LITERAL:
13428 label = UnqualifiedID();
13429 break;
13430 default:
13431 jj_la1[146] = jj_gen;
13432 ;
13433 }
13434 switch (jj_nt.kind) {
13435 case WHEN:
13436 jj_consume_token(WHEN);
13437 Expression();
13438 break;
13439 default:
13440 jj_la1[147] = jj_gen;
13441 ;
13442 }
13443 jjtree.closeNodeScope(jjtn000, true);
13444 jjtc000 = false;
13445 if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13446 } catch (Throwable jjte000) {
13447 if (jjtc000) {
13448 jjtree.clearNodeScope(jjtn000);
13449 jjtc000 = false;
13450 } else {
13451 jjtree.popNode();
13452 }
13453 if (jjte000 instanceof RuntimeException) {
13454 {if (true) throw (RuntimeException)jjte000;}
13455 }
13456 if (jjte000 instanceof ParseException) {
13457 {if (true) throw (ParseException)jjte000;}
13458 }
13459 {if (true) throw (Error)jjte000;}
13460 } finally {
13461 if (jjtc000) {
13462 jjtree.closeNodeScope(jjtn000, true);
13463 }
13464 }
13465 throw new Error("Missing return statement in function");
13466 }
13467
13468 final public ASTExitStatement ExitStatement() throws ParseException {
13469
13470 ASTExitStatement jjtn000 = new ASTExitStatement(this, JJTEXITSTATEMENT);
13471 boolean jjtc000 = true;
13472 jjtree.openNodeScope(jjtn000);PLSQLNode label = null;
13473 try {
13474 jj_consume_token(EXIT);
13475 switch (jj_nt.kind) {
13476 case REPLACE:
13477 case DEFINER:
13478 case CURRENT_USER:
13479 case LANGUAGE:
13480 case ADD:
13481 case AGGREGATE:
13482 case ARRAY:
13483 case AT:
13484 case ATTRIBUTE:
13485 case AUTHID:
13486 case BODY:
13487 case BULK:
13488 case BYTE:
13489 case CASCADE:
13490 case CLOSE:
13491 case COALESCE:
13492 case COLLECT:
13493 case COLUMN:
13494 case COMMENT:
13495 case COMMIT:
13496 case CONSTRUCTOR:
13497 case CONTINUE:
13498 case CONVERT:
13499 case CURRENT:
13500 case CURSOR:
13501 case DATA:
13502 case DAY:
13503 case DISABLE:
13504 case EDITIONABLE:
13505 case ELEMENT:
13506 case ENABLE:
13507 case ESCAPE:
13508 case EXCEPT:
13509 case EXCEPTIONS:
13510 case EXIT:
13511 case EXTERNAL:
13512 case EXTENDS:
13513 case EXTRACT:
13514 case FALSE:
13515 case FINAL:
13516 case FORCE:
13517 case FUNCTION:
13518 case GLOBAL:
13519 case HASH:
13520 case HEAP:
13521 case HOUR:
13522 case IMMEDIATE:
13523 case INDICES:
13524 case INDEXTYPE:
13525 case INDICATOR:
13526 case INSTANTIABLE:
13527 case INTERVAL:
13528 case INVALIDATE:
13529 case ISOLATION:
13530 case JAVA:
13531 case LEVEL:
13532 case LIMIT:
13533 case LOOP:
13534 case MAP:
13535 case MAX:
13536 case MEMBER:
13537 case MERGE:
13538 case MIN:
13539 case MINUTE:
13540 case MLSLABEL:
13541 case MODIFY:
13542 case MOD:
13543 case MONTH:
13544 case NATURAL:
13545 case NEW:
13546 case NO:
13547 case NONEDITIONABLE:
13548 case NULLIF:
13549 case OBJECT:
13550 case OID:
13551 case OPAQUE:
13552 case OPEN:
13553 case OPERATOR:
13554 case ORGANIZATION:
13555 case OTHERS:
13556 case OVERRIDING:
13557 case PACKAGE:
13558 case PARTITION:
13559 case PRESERVE:
13560 case PRIVATE:
13561 case PROCEDURE:
13562 case RANGE:
13563 case RAW:
13564 case REAL:
13565 case RECORD:
13566 case REF:
13567 case RELEASE:
13568 case RELIES_ON:
13569 case RENAME:
13570 case RESULT:
13571 case RETURN:
13572 case RETURNING:
13573 case REVERSE:
13574 case ROLLBACK:
13575 case ROW:
13576 case ROWS:
13577 case ROWID:
13578 case ROWNUM:
13579 case SAVE:
13580 case SAVEPOINT:
13581 case SECOND:
13582 case SELF:
13583 case SET:
13584 case SPACE:
13585 case SQL:
13586 case SQLCODE:
13587 case SQLERRM:
13588 case STATIC:
13589 case SUBTYPE:
13590 case SUBSTITUTABLE:
13591 case SUCCESSFUL:
13592 case SYSDATE:
13593 case SYS_REFCURSOR:
13594 case TEMPORARY:
13595 case TIME:
13596 case TIMESTAMP:
13597 case TIMEZONE_REGION:
13598 case TIMEZONE_ABBR:
13599 case TIMEZONE_MINUTE:
13600 case TIMEZONE_HOUR:
13601 case TRANSACTION:
13602 case TRUE:
13603 case TYPE:
13604 case UNDER:
13605 case USING:
13606 case YES:
13607 case SHOW:
13608 case A:
13609 case DOUBLE:
13610 case DEC:
13611 case PRECISION:
13612 case INT:
13613 case NUMERIC:
13614 case NCHAR:
13615 case NVARCHAR2:
13616 case STRING:
13617 case UROWID:
13618 case VARRAY:
13619 case VARYING:
13620 case BFILE:
13621 case BLOB:
13622 case CLOB:
13623 case NCLOB:
13624 case YEAR:
13625 case LOCAL:
13626 case ZONE:
13627 case CHARACTER:
13628 case AFTER:
13629 case BEFORE:
13630 case OLD:
13631 case PARENT:
13632 case ANALYZE:
13633 case ASSOCIATE:
13634 case AUDIT:
13635 case COMPOUND:
13636 case DATABASE:
13637 case CALL:
13638 case DDL:
13639 case DISASSOCIATE:
13640 case EACH:
13641 case FOLLOWS:
13642 case LOGOFF:
13643 case LOGON:
13644 case NESTED:
13645 case NOAUDIT:
13646 case SCHEMA:
13647 case SERVERERROR:
13648 case SHUTDOWN:
13649 case STARTUP:
13650 case STATEMENT:
13651 case STATISTICS:
13652 case SUSPEND:
13653 case TRUNCATE:
13654 case WRAPPED:
13655 case LIBRARY:
13656 case NAME:
13657 case STRUCT:
13658 case CONTEXT:
13659 case PARAMETERS:
13660 case LENGTH:
13661 case TDO:
13662 case MAXLEN:
13663 case CHARSETID:
13664 case CHARSETFORM:
13665 case ACCEPT:
13666 case ACCESSIBLE:
13667 case COPY:
13668 case DEFINE:
13669 case DISCONNECT:
13670 case HOST:
13671 case PRINT:
13672 case QUIT:
13673 case REMARK:
13674 case UNDEFINE:
13675 case VARIABLE:
13676 case WHENEVER:
13677 case ATTACH:
13678 case CAST:
13679 case TREAT:
13680 case TRIM:
13681 case LEFT:
13682 case RIGHT:
13683 case BOTH:
13684 case EMPTY:
13685 case MULTISET:
13686 case SUBMULTISET:
13687 case LEADING:
13688 case TRAILING:
13689 case CHAR_CS:
13690 case NCHAR_CS:
13691 case DBTIMEZONE:
13692 case SESSIONTIMEZONE:
13693 case AUTHENTICATED:
13694 case LINK:
13695 case SHARED:
13696 case DIRECTORY:
13697 case USER:
13698 case IDENTIFIER:
13699 case QUOTED_LITERAL:
13700 label = UnqualifiedID();
13701 break;
13702 default:
13703 jj_la1[148] = jj_gen;
13704 ;
13705 }
13706 switch (jj_nt.kind) {
13707 case WHEN:
13708 jj_consume_token(WHEN);
13709 Expression();
13710 break;
13711 default:
13712 jj_la1[149] = jj_gen;
13713 ;
13714 }
13715 jjtree.closeNodeScope(jjtn000, true);
13716 jjtc000 = false;
13717 if (null != label) { jjtn000.setImage(label.getImage()) ; } {if (true) return jjtn000 ;}
13718 } catch (Throwable jjte000) {
13719 if (jjtc000) {
13720 jjtree.clearNodeScope(jjtn000);
13721 jjtc000 = false;
13722 } else {
13723 jjtree.popNode();
13724 }
13725 if (jjte000 instanceof RuntimeException) {
13726 {if (true) throw (RuntimeException)jjte000;}
13727 }
13728 if (jjte000 instanceof ParseException) {
13729 {if (true) throw (ParseException)jjte000;}
13730 }
13731 {if (true) throw (Error)jjte000;}
13732 } finally {
13733 if (jjtc000) {
13734 jjtree.closeNodeScope(jjtn000, true);
13735 }
13736 }
13737 throw new Error("Missing return statement in function");
13738 }
13739
13740 final public ASTRaiseStatement RaiseStatement() throws ParseException {
13741
13742 ASTRaiseStatement jjtn000 = new ASTRaiseStatement(this, JJTRAISESTATEMENT);
13743 boolean jjtc000 = true;
13744 jjtree.openNodeScope(jjtn000);PLSQLNode exception = null ;
13745 try {
13746 jj_consume_token(RAISE);
13747 switch (jj_nt.kind) {
13748 case REPLACE:
13749 case DEFINER:
13750 case CURRENT_USER:
13751 case LANGUAGE:
13752 case ADD:
13753 case AGGREGATE:
13754 case ARRAY:
13755 case AT:
13756 case ATTRIBUTE:
13757 case AUTHID:
13758 case BODY:
13759 case BULK:
13760 case BYTE:
13761 case CASCADE:
13762 case CLOSE:
13763 case COALESCE:
13764 case COLLECT:
13765 case COLUMN:
13766 case COMMENT:
13767 case COMMIT:
13768 case CONSTRUCTOR:
13769 case CONTINUE:
13770 case CONVERT:
13771 case CURRENT:
13772 case CURSOR:
13773 case DATA:
13774 case DAY:
13775 case DISABLE:
13776 case EDITIONABLE:
13777 case ELEMENT:
13778 case ENABLE:
13779 case ESCAPE:
13780 case EXCEPT:
13781 case EXCEPTIONS:
13782 case EXIT:
13783 case EXTERNAL:
13784 case EXTENDS:
13785 case EXTRACT:
13786 case FALSE:
13787 case FINAL:
13788 case FORCE:
13789 case FUNCTION:
13790 case GLOBAL:
13791 case HASH:
13792 case HEAP:
13793 case HOUR:
13794 case IMMEDIATE:
13795 case INDICES:
13796 case INDEXTYPE:
13797 case INDICATOR:
13798 case INSTANTIABLE:
13799 case INTERVAL:
13800 case INVALIDATE:
13801 case ISOLATION:
13802 case JAVA:
13803 case LEVEL:
13804 case LIMIT:
13805 case LOOP:
13806 case MAP:
13807 case MAX:
13808 case MEMBER:
13809 case MERGE:
13810 case MIN:
13811 case MINUTE:
13812 case MLSLABEL:
13813 case MODIFY:
13814 case MOD:
13815 case MONTH:
13816 case NATURAL:
13817 case NEW:
13818 case NO:
13819 case NONEDITIONABLE:
13820 case NULLIF:
13821 case OBJECT:
13822 case OID:
13823 case OPAQUE:
13824 case OPEN:
13825 case OPERATOR:
13826 case ORGANIZATION:
13827 case OTHERS:
13828 case OVERRIDING:
13829 case PACKAGE:
13830 case PARTITION:
13831 case PRESERVE:
13832 case PRIVATE:
13833 case PROCEDURE:
13834 case RANGE:
13835 case RAW:
13836 case REAL:
13837 case RECORD:
13838 case REF:
13839 case RELEASE:
13840 case RELIES_ON:
13841 case RENAME:
13842 case RESULT:
13843 case RETURN:
13844 case RETURNING:
13845 case REVERSE:
13846 case ROLLBACK:
13847 case ROW:
13848 case ROWS:
13849 case ROWID:
13850 case ROWNUM:
13851 case SAVE:
13852 case SAVEPOINT:
13853 case SECOND:
13854 case SELF:
13855 case SET:
13856 case SPACE:
13857 case SQL:
13858 case SQLCODE:
13859 case SQLERRM:
13860 case STATIC:
13861 case SUBTYPE:
13862 case SUBSTITUTABLE:
13863 case SUCCESSFUL:
13864 case SYSDATE:
13865 case SYS_REFCURSOR:
13866 case TEMPORARY:
13867 case TIME:
13868 case TIMESTAMP:
13869 case TIMEZONE_REGION:
13870 case TIMEZONE_ABBR:
13871 case TIMEZONE_MINUTE:
13872 case TIMEZONE_HOUR:
13873 case TRANSACTION:
13874 case TRUE:
13875 case TYPE:
13876 case UNDER:
13877 case USING:
13878 case YES:
13879 case SHOW:
13880 case A:
13881 case DOUBLE:
13882 case DEC:
13883 case PRECISION:
13884 case INT:
13885 case NUMERIC:
13886 case NCHAR:
13887 case NVARCHAR2:
13888 case STRING:
13889 case UROWID:
13890 case VARRAY:
13891 case VARYING:
13892 case BFILE:
13893 case BLOB:
13894 case CLOB:
13895 case NCLOB:
13896 case YEAR:
13897 case LOCAL:
13898 case ZONE:
13899 case CHARACTER:
13900 case AFTER:
13901 case BEFORE:
13902 case OLD:
13903 case PARENT:
13904 case ANALYZE:
13905 case ASSOCIATE:
13906 case AUDIT:
13907 case COMPOUND:
13908 case DATABASE:
13909 case CALL:
13910 case DDL:
13911 case DISASSOCIATE:
13912 case EACH:
13913 case FOLLOWS:
13914 case LOGOFF:
13915 case LOGON:
13916 case NESTED:
13917 case NOAUDIT:
13918 case SCHEMA:
13919 case SERVERERROR:
13920 case SHUTDOWN:
13921 case STARTUP:
13922 case STATEMENT:
13923 case STATISTICS:
13924 case SUSPEND:
13925 case TRUNCATE:
13926 case WRAPPED:
13927 case LIBRARY:
13928 case NAME:
13929 case STRUCT:
13930 case CONTEXT:
13931 case PARAMETERS:
13932 case LENGTH:
13933 case TDO:
13934 case MAXLEN:
13935 case CHARSETID:
13936 case CHARSETFORM:
13937 case ACCEPT:
13938 case ACCESSIBLE:
13939 case COPY:
13940 case DEFINE:
13941 case DISCONNECT:
13942 case HOST:
13943 case PRINT:
13944 case QUIT:
13945 case REMARK:
13946 case UNDEFINE:
13947 case VARIABLE:
13948 case WHENEVER:
13949 case ATTACH:
13950 case CAST:
13951 case TREAT:
13952 case TRIM:
13953 case LEFT:
13954 case RIGHT:
13955 case BOTH:
13956 case EMPTY:
13957 case MULTISET:
13958 case SUBMULTISET:
13959 case LEADING:
13960 case TRAILING:
13961 case CHAR_CS:
13962 case NCHAR_CS:
13963 case DBTIMEZONE:
13964 case SESSIONTIMEZONE:
13965 case AUTHENTICATED:
13966 case LINK:
13967 case SHARED:
13968 case DIRECTORY:
13969 case USER:
13970 case IDENTIFIER:
13971 case QUOTED_LITERAL:
13972 exception = QualifiedName();
13973 break;
13974 default:
13975 jj_la1[150] = jj_gen;
13976 ;
13977 }
13978 jjtree.closeNodeScope(jjtn000, true);
13979 jjtc000 = false;
13980 if (null != exception) { jjtn000.setImage(exception.getImage()) ; } {if (true) return jjtn000 ;}
13981 } catch (Throwable jjte000) {
13982 if (jjtc000) {
13983 jjtree.clearNodeScope(jjtn000);
13984 jjtc000 = false;
13985 } else {
13986 jjtree.popNode();
13987 }
13988 if (jjte000 instanceof RuntimeException) {
13989 {if (true) throw (RuntimeException)jjte000;}
13990 }
13991 if (jjte000 instanceof ParseException) {
13992 {if (true) throw (ParseException)jjte000;}
13993 }
13994 {if (true) throw (Error)jjte000;}
13995 } finally {
13996 if (jjtc000) {
13997 jjtree.closeNodeScope(jjtn000, true);
13998 }
13999 }
14000 throw new Error("Missing return statement in function");
14001 }
14002
14003 final public ASTCloseStatement CloseStatement() throws ParseException {
14004
14005 ASTCloseStatement jjtn000 = new ASTCloseStatement(this, JJTCLOSESTATEMENT);
14006 boolean jjtc000 = true;
14007 jjtree.openNodeScope(jjtn000);PLSQLNode cursor = null ;
14008 try {
14009 jj_consume_token(CLOSE);
14010 cursor = QualifiedName();
14011 jjtree.closeNodeScope(jjtn000, true);
14012 jjtc000 = false;
14013 jjtn000.setImage(cursor.getImage()) ; {if (true) return jjtn000 ;}
14014 } catch (Throwable jjte000) {
14015 if (jjtc000) {
14016 jjtree.clearNodeScope(jjtn000);
14017 jjtc000 = false;
14018 } else {
14019 jjtree.popNode();
14020 }
14021 if (jjte000 instanceof RuntimeException) {
14022 {if (true) throw (RuntimeException)jjte000;}
14023 }
14024 if (jjte000 instanceof ParseException) {
14025 {if (true) throw (ParseException)jjte000;}
14026 }
14027 {if (true) throw (Error)jjte000;}
14028 } finally {
14029 if (jjtc000) {
14030 jjtree.closeNodeScope(jjtn000, true);
14031 }
14032 }
14033 throw new Error("Missing return statement in function");
14034 }
14035
14036 final public ASTOpenStatement OpenStatement() throws ParseException {
14037
14038 ASTOpenStatement jjtn000 = new ASTOpenStatement(this, JJTOPENSTATEMENT);
14039 boolean jjtc000 = true;
14040 jjtree.openNodeScope(jjtn000);
14041 try {
14042 jj_consume_token(OPEN);
14043 switch (jj_nt.kind) {
14044 case 5:
14045 case 16:
14046 case 17:
14047 case REPLACE:
14048 case DEFINER:
14049 case CURRENT_USER:
14050 case LANGUAGE:
14051 case ADD:
14052 case AGGREGATE:
14053 case ARRAY:
14054 case AT:
14055 case ATTRIBUTE:
14056 case AUTHID:
14057 case BODY:
14058 case BULK:
14059 case BYTE:
14060 case CASCADE:
14061 case CASE:
14062 case CLOSE:
14063 case COALESCE:
14064 case COLLECT:
14065 case COLUMN:
14066 case COMMENT:
14067 case COMMIT:
14068 case CONSTRUCTOR:
14069 case CONTINUE:
14070 case CONVERT:
14071 case CURRENT:
14072 case CURSOR:
14073 case DATA:
14074 case DATE:
14075 case DAY:
14076 case DISABLE:
14077 case EDITIONABLE:
14078 case ELEMENT:
14079 case ENABLE:
14080 case ESCAPE:
14081 case EXCEPT:
14082 case EXCEPTIONS:
14083 case EXIT:
14084 case EXTERNAL:
14085 case EXTENDS:
14086 case EXTRACT:
14087 case FALSE:
14088 case FINAL:
14089 case FORCE:
14090 case FUNCTION:
14091 case GLOBAL:
14092 case HASH:
14093 case HEAP:
14094 case HOUR:
14095 case IMMEDIATE:
14096 case INDICES:
14097 case INDEXTYPE:
14098 case INDICATOR:
14099 case INSTANTIABLE:
14100 case INTERVAL:
14101 case INVALIDATE:
14102 case ISOLATION:
14103 case JAVA:
14104 case LEVEL:
14105 case LIMIT:
14106 case LOOP:
14107 case MAP:
14108 case MAX:
14109 case MEMBER:
14110 case MERGE:
14111 case MIN:
14112 case MINUTE:
14113 case MLSLABEL:
14114 case MODIFY:
14115 case MOD:
14116 case MONTH:
14117 case NATURAL:
14118 case NEW:
14119 case NEW_DOT:
14120 case NO:
14121 case NONEDITIONABLE:
14122 case NOT:
14123 case NULL:
14124 case NULLIF:
14125 case OBJECT:
14126 case OID:
14127 case OPAQUE:
14128 case OPEN:
14129 case OPERATOR:
14130 case ORGANIZATION:
14131 case OTHERS:
14132 case OVERRIDING:
14133 case PACKAGE:
14134 case PARTITION:
14135 case PRESERVE:
14136 case PRIVATE:
14137 case PROCEDURE:
14138 case RANGE:
14139 case RAW:
14140 case REAL:
14141 case RECORD:
14142 case REF:
14143 case RELEASE:
14144 case RELIES_ON:
14145 case RENAME:
14146 case RESULT:
14147 case RETURN:
14148 case RETURNING:
14149 case REVERSE:
14150 case ROLLBACK:
14151 case ROW:
14152 case ROWS:
14153 case ROWID:
14154 case ROWNUM:
14155 case SAVE:
14156 case SAVEPOINT:
14157 case SECOND:
14158 case SELECT:
14159 case SELF:
14160 case SET:
14161 case SPACE:
14162 case SQL:
14163 case SQLCODE:
14164 case SQLERRM:
14165 case STATIC:
14166 case SUBTYPE:
14167 case SUBSTITUTABLE:
14168 case SUCCESSFUL:
14169 case SYSDATE:
14170 case SYS_REFCURSOR:
14171 case TEMPORARY:
14172 case TIME:
14173 case TIMESTAMP:
14174 case TIMEZONE_REGION:
14175 case TIMEZONE_ABBR:
14176 case TIMEZONE_MINUTE:
14177 case TIMEZONE_HOUR:
14178 case TRANSACTION:
14179 case TRUE:
14180 case TYPE:
14181 case UNDER:
14182 case USING:
14183 case YES:
14184 case SHOW:
14185 case A:
14186 case DOUBLE:
14187 case DEC:
14188 case PRECISION:
14189 case INT:
14190 case NUMERIC:
14191 case NCHAR:
14192 case NVARCHAR2:
14193 case STRING:
14194 case UROWID:
14195 case VARRAY:
14196 case VARYING:
14197 case BFILE:
14198 case BLOB:
14199 case CLOB:
14200 case NCLOB:
14201 case YEAR:
14202 case LOCAL:
14203 case WITH:
14204 case ZONE:
14205 case CHARACTER:
14206 case AFTER:
14207 case BEFORE:
14208 case OLD:
14209 case PARENT:
14210 case CC_IF:
14211 case ANALYZE:
14212 case ASSOCIATE:
14213 case AUDIT:
14214 case COMPOUND:
14215 case DATABASE:
14216 case CALL:
14217 case DDL:
14218 case DISASSOCIATE:
14219 case EACH:
14220 case FOLLOWS:
14221 case LOGOFF:
14222 case LOGON:
14223 case NESTED:
14224 case NOAUDIT:
14225 case SCHEMA:
14226 case SERVERERROR:
14227 case SHUTDOWN:
14228 case STARTUP:
14229 case STATEMENT:
14230 case STATISTICS:
14231 case SUSPEND:
14232 case TRUNCATE:
14233 case WRAPPED:
14234 case LIBRARY:
14235 case NAME:
14236 case STRUCT:
14237 case CONTEXT:
14238 case PARAMETERS:
14239 case LENGTH:
14240 case TDO:
14241 case MAXLEN:
14242 case CHARSETID:
14243 case CHARSETFORM:
14244 case ACCEPT:
14245 case ACCESSIBLE:
14246 case COPY:
14247 case DEFINE:
14248 case DISCONNECT:
14249 case HOST:
14250 case PRINT:
14251 case QUIT:
14252 case REMARK:
14253 case UNDEFINE:
14254 case VARIABLE:
14255 case WHENEVER:
14256 case ATTACH:
14257 case CAST:
14258 case TREAT:
14259 case TRIM:
14260 case LEFT:
14261 case RIGHT:
14262 case BOTH:
14263 case EMPTY:
14264 case MULTISET:
14265 case SUBMULTISET:
14266 case LEADING:
14267 case TRAILING:
14268 case CHAR_CS:
14269 case NCHAR_CS:
14270 case DBTIMEZONE:
14271 case SESSIONTIMEZONE:
14272 case AUTHENTICATED:
14273 case LINK:
14274 case SHARED:
14275 case DIRECTORY:
14276 case USER:
14277 case IDENTIFIER:
14278 case UNSIGNED_NUMERIC_LITERAL:
14279 case CHARACTER_LITERAL:
14280 case STRING_LITERAL:
14281 case QUOTED_LITERAL:
14282 Expression();
14283 break;
14284 default:
14285 jj_la1[151] = jj_gen;
14286 ;
14287 }
14288 switch (jj_nt.kind) {
14289 case FOR:
14290 jj_consume_token(FOR);
14291 Expression();
14292 switch (jj_nt.kind) {
14293 case USING:
14294 jj_consume_token(USING);
14295 Expression();
14296 label_34:
14297 while (true) {
14298 switch (jj_nt.kind) {
14299 case 6:
14300 ;
14301 break;
14302 default:
14303 jj_la1[152] = jj_gen;
14304 break label_34;
14305 }
14306 jj_consume_token(6);
14307 Expression();
14308 }
14309 break;
14310 default:
14311 jj_la1[153] = jj_gen;
14312 ;
14313 }
14314 break;
14315 default:
14316 jj_la1[154] = jj_gen;
14317 ;
14318 }
14319 jjtree.closeNodeScope(jjtn000, true);
14320 jjtc000 = false;
14321 {if (true) return jjtn000 ;}
14322 } catch (Throwable jjte000) {
14323 if (jjtc000) {
14324 jjtree.clearNodeScope(jjtn000);
14325 jjtc000 = false;
14326 } else {
14327 jjtree.popNode();
14328 }
14329 if (jjte000 instanceof RuntimeException) {
14330 {if (true) throw (RuntimeException)jjte000;}
14331 }
14332 if (jjte000 instanceof ParseException) {
14333 {if (true) throw (ParseException)jjte000;}
14334 }
14335 {if (true) throw (Error)jjte000;}
14336 } finally {
14337 if (jjtc000) {
14338 jjtree.closeNodeScope(jjtn000, true);
14339 }
14340 }
14341 throw new Error("Missing return statement in function");
14342 }
14343
14344 final public ASTFetchStatement FetchStatement() throws ParseException {
14345
14346 ASTFetchStatement jjtn000 = new ASTFetchStatement(this, JJTFETCHSTATEMENT);
14347 boolean jjtc000 = true;
14348 jjtree.openNodeScope(jjtn000);
14349 try {
14350 jj_consume_token(FETCH);
14351 QualifiedName();
14352 switch (jj_nt.kind) {
14353 case BULK:
14354 jj_consume_token(BULK);
14355 jj_consume_token(COLLECT);
14356 break;
14357 default:
14358 jj_la1[155] = jj_gen;
14359 ;
14360 }
14361 jj_consume_token(INTO);
14362 Expression();
14363 label_35:
14364 while (true) {
14365 switch (jj_nt.kind) {
14366 case 6:
14367 ;
14368 break;
14369 default:
14370 jj_la1[156] = jj_gen;
14371 break label_35;
14372 }
14373 jj_consume_token(6);
14374 Expression();
14375 }
14376 switch (jj_nt.kind) {
14377 case LIMIT:
14378 jj_consume_token(LIMIT);
14379 Expression();
14380 break;
14381 default:
14382 jj_la1[157] = jj_gen;
14383 ;
14384 }
14385 jjtree.closeNodeScope(jjtn000, true);
14386 jjtc000 = false;
14387 {if (true) return jjtn000 ;}
14388 } catch (Throwable jjte000) {
14389 if (jjtc000) {
14390 jjtree.clearNodeScope(jjtn000);
14391 jjtc000 = false;
14392 } else {
14393 jjtree.popNode();
14394 }
14395 if (jjte000 instanceof RuntimeException) {
14396 {if (true) throw (RuntimeException)jjte000;}
14397 }
14398 if (jjte000 instanceof ParseException) {
14399 {if (true) throw (ParseException)jjte000;}
14400 }
14401 {if (true) throw (Error)jjte000;}
14402 } finally {
14403 if (jjtc000) {
14404 jjtree.closeNodeScope(jjtn000, true);
14405 }
14406 }
14407 throw new Error("Missing return statement in function");
14408 }
14409
14410 final public ASTEmbeddedSqlStatement EmbeddedSqlStatement() throws ParseException {
14411
14412 ASTEmbeddedSqlStatement jjtn000 = new ASTEmbeddedSqlStatement(this, JJTEMBEDDEDSQLSTATEMENT);
14413 boolean jjtc000 = true;
14414 jjtree.openNodeScope(jjtn000);
14415 try {
14416 jj_consume_token(EXECUTE);
14417 jj_consume_token(IMMEDIATE);
14418 Expression();
14419 switch (jj_nt.kind) {
14420 case INTO:
14421 jj_consume_token(INTO);
14422 Name();
14423 label_36:
14424 while (true) {
14425 switch (jj_nt.kind) {
14426 case 6:
14427 ;
14428 break;
14429 default:
14430 jj_la1[158] = jj_gen;
14431 break label_36;
14432 }
14433 jj_consume_token(6);
14434 Name();
14435 }
14436 break;
14437 default:
14438 jj_la1[159] = jj_gen;
14439 ;
14440 }
14441 switch (jj_nt.kind) {
14442 case USING:
14443 jj_consume_token(USING);
14444 switch (jj_nt.kind) {
14445 case IN:
14446 case OUT:
14447 switch (jj_nt.kind) {
14448 case IN:
14449 jj_consume_token(IN);
14450 switch (jj_nt.kind) {
14451 case OUT:
14452 jj_consume_token(OUT);
14453 break;
14454 default:
14455 jj_la1[160] = jj_gen;
14456 ;
14457 }
14458 break;
14459 case OUT:
14460 jj_consume_token(OUT);
14461 break;
14462 default:
14463 jj_la1[161] = jj_gen;
14464 jj_consume_token(-1);
14465 throw new ParseException();
14466 }
14467 break;
14468 default:
14469 jj_la1[162] = jj_gen;
14470 ;
14471 }
14472 Expression();
14473 label_37:
14474 while (true) {
14475 switch (jj_nt.kind) {
14476 case 6:
14477 ;
14478 break;
14479 default:
14480 jj_la1[163] = jj_gen;
14481 break label_37;
14482 }
14483 jj_consume_token(6);
14484 switch (jj_nt.kind) {
14485 case IN:
14486 case OUT:
14487 switch (jj_nt.kind) {
14488 case IN:
14489 jj_consume_token(IN);
14490 switch (jj_nt.kind) {
14491 case OUT:
14492 jj_consume_token(OUT);
14493 break;
14494 default:
14495 jj_la1[164] = jj_gen;
14496 ;
14497 }
14498 break;
14499 case OUT:
14500 jj_consume_token(OUT);
14501 break;
14502 default:
14503 jj_la1[165] = jj_gen;
14504 jj_consume_token(-1);
14505 throw new ParseException();
14506 }
14507 break;
14508 default:
14509 jj_la1[166] = jj_gen;
14510 ;
14511 }
14512 Expression();
14513 }
14514 break;
14515 default:
14516 jj_la1[167] = jj_gen;
14517 ;
14518 }
14519 switch (jj_nt.kind) {
14520 case RETURN:
14521 case RETURNING:
14522 switch (jj_nt.kind) {
14523 case RETURN:
14524 jj_consume_token(RETURN);
14525 break;
14526 case RETURNING:
14527 jj_consume_token(RETURNING);
14528 break;
14529 default:
14530 jj_la1[168] = jj_gen;
14531 jj_consume_token(-1);
14532 throw new ParseException();
14533 }
14534 jj_consume_token(INTO);
14535 Expression();
14536 label_38:
14537 while (true) {
14538 switch (jj_nt.kind) {
14539 case 6:
14540 ;
14541 break;
14542 default:
14543 jj_la1[169] = jj_gen;
14544 break label_38;
14545 }
14546 jj_consume_token(6);
14547 Expression();
14548 }
14549 break;
14550 default:
14551 jj_la1[170] = jj_gen;
14552 ;
14553 }
14554 jj_consume_token(4);
14555 jjtree.closeNodeScope(jjtn000, true);
14556 jjtc000 = false;
14557 {if (true) return jjtn000 ;}
14558 } catch (Throwable jjte000) {
14559 if (jjtc000) {
14560 jjtree.clearNodeScope(jjtn000);
14561 jjtc000 = false;
14562 } else {
14563 jjtree.popNode();
14564 }
14565 if (jjte000 instanceof RuntimeException) {
14566 {if (true) throw (RuntimeException)jjte000;}
14567 }
14568 if (jjte000 instanceof ParseException) {
14569 {if (true) throw (ParseException)jjte000;}
14570 }
14571 {if (true) throw (Error)jjte000;}
14572 } finally {
14573 if (jjtc000) {
14574 jjtree.closeNodeScope(jjtn000, true);
14575 }
14576 }
14577 throw new Error("Missing return statement in function");
14578 }
14579
14580 final public ASTPipelineStatement PipelineStatement() throws ParseException {
14581
14582 ASTPipelineStatement jjtn000 = new ASTPipelineStatement(this, JJTPIPELINESTATEMENT);
14583 boolean jjtc000 = true;
14584 jjtree.openNodeScope(jjtn000);
14585 try {
14586 jj_consume_token(PIPE);
14587 jj_consume_token(ROW);
14588 Expression();
14589 jjtree.closeNodeScope(jjtn000, true);
14590 jjtc000 = false;
14591 {if (true) return jjtn000 ;}
14592 } catch (Throwable jjte000) {
14593 if (jjtc000) {
14594 jjtree.clearNodeScope(jjtn000);
14595 jjtc000 = false;
14596 } else {
14597 jjtree.popNode();
14598 }
14599 if (jjte000 instanceof RuntimeException) {
14600 {if (true) throw (RuntimeException)jjte000;}
14601 }
14602 if (jjte000 instanceof ParseException) {
14603 {if (true) throw (ParseException)jjte000;}
14604 }
14605 {if (true) throw (Error)jjte000;}
14606 } finally {
14607 if (jjtc000) {
14608 jjtree.closeNodeScope(jjtn000, true);
14609 }
14610 }
14611 throw new Error("Missing return statement in function");
14612 }
14613
14614 final public ASTConditionalCompilationStatement ConditionalCompilationStatement() throws ParseException {
14615
14616 ASTConditionalCompilationStatement jjtn000 = new ASTConditionalCompilationStatement(this, JJTCONDITIONALCOMPILATIONSTATEMENT);
14617 boolean jjtc000 = true;
14618 jjtree.openNodeScope(jjtn000);
14619 try {
14620 switch (jj_nt.kind) {
14621 case CC_IF:
14622 jj_consume_token(CC_IF);
14623 ConditionalOrExpression();
14624 jj_consume_token(CC_THEN);
14625 label_39:
14626 while (true) {
14627 switch (jj_nt.kind) {
14628 case 5:
14629 case 16:
14630 case 17:
14631 case 21:
14632 case REPLACE:
14633 case DEFINER:
14634 case CURRENT_USER:
14635 case LANGUAGE:
14636 case ADD:
14637 case AGGREGATE:
14638 case ARRAY:
14639 case AT:
14640 case ATTRIBUTE:
14641 case AUTHID:
14642 case BEGIN:
14643 case BODY:
14644 case BULK:
14645 case BYTE:
14646 case CASCADE:
14647 case CASE:
14648 case CLOSE:
14649 case COALESCE:
14650 case COLLECT:
14651 case COLUMN:
14652 case COMMENT:
14653 case COMMIT:
14654 case CONSTRUCTOR:
14655 case CONTINUE:
14656 case CONVERT:
14657 case CURRENT:
14658 case CURSOR:
14659 case DATA:
14660 case DATE:
14661 case DAY:
14662 case DECLARE:
14663 case DELETE:
14664 case DISABLE:
14665 case EDITIONABLE:
14666 case ELEMENT:
14667 case ENABLE:
14668 case ESCAPE:
14669 case EXCEPT:
14670 case EXCEPTIONS:
14671 case EXECUTE:
14672 case EXIT:
14673 case EXTERNAL:
14674 case EXTENDS:
14675 case EXTRACT:
14676 case FALSE:
14677 case FETCH:
14678 case FINAL:
14679 case FOR:
14680 case FORALL:
14681 case FORCE:
14682 case FUNCTION:
14683 case GLOBAL:
14684 case GOTO:
14685 case HASH:
14686 case HEAP:
14687 case HOUR:
14688 case IF:
14689 case IMMEDIATE:
14690 case INDICES:
14691 case INDEXTYPE:
14692 case INDICATOR:
14693 case INSERT:
14694 case INSTANTIABLE:
14695 case INTERVAL:
14696 case INVALIDATE:
14697 case ISOLATION:
14698 case JAVA:
14699 case LEVEL:
14700 case LIMIT:
14701 case LOCK:
14702 case LOOP:
14703 case MAP:
14704 case MAX:
14705 case MEMBER:
14706 case MERGE:
14707 case MIN:
14708 case MINUTE:
14709 case MLSLABEL:
14710 case MODIFY:
14711 case MOD:
14712 case MONTH:
14713 case NATURAL:
14714 case NEW:
14715 case NEW_DOT:
14716 case NO:
14717 case NONEDITIONABLE:
14718 case NOT:
14719 case NULL:
14720 case NULLIF:
14721 case OBJECT:
14722 case OID:
14723 case OPAQUE:
14724 case OPEN:
14725 case OPERATOR:
14726 case ORGANIZATION:
14727 case OTHERS:
14728 case OVERRIDING:
14729 case PACKAGE:
14730 case PARTITION:
14731 case PIPE:
14732 case PRESERVE:
14733 case PRIVATE:
14734 case PROCEDURE:
14735 case RAISE:
14736 case RANGE:
14737 case RAW:
14738 case REAL:
14739 case RECORD:
14740 case REF:
14741 case RELEASE:
14742 case RELIES_ON:
14743 case RENAME:
14744 case RESULT:
14745 case RETURN:
14746 case RETURNING:
14747 case REVERSE:
14748 case ROLLBACK:
14749 case ROW:
14750 case ROWS:
14751 case ROWID:
14752 case ROWNUM:
14753 case SAVE:
14754 case SAVEPOINT:
14755 case SECOND:
14756 case SELECT:
14757 case SELF:
14758 case SET:
14759 case SPACE:
14760 case SQL:
14761 case SQLCODE:
14762 case SQLERRM:
14763 case STATIC:
14764 case SUBTYPE:
14765 case SUBSTITUTABLE:
14766 case SUCCESSFUL:
14767 case SYSDATE:
14768 case SYS_REFCURSOR:
14769 case TEMPORARY:
14770 case TIME:
14771 case TIMESTAMP:
14772 case TIMEZONE_REGION:
14773 case TIMEZONE_ABBR:
14774 case TIMEZONE_MINUTE:
14775 case TIMEZONE_HOUR:
14776 case TRANSACTION:
14777 case TRUE:
14778 case TYPE:
14779 case UNDER:
14780 case USING:
14781 case WHILE:
14782 case YES:
14783 case SHOW:
14784 case A:
14785 case UPDATE:
14786 case DOUBLE:
14787 case DEC:
14788 case PRECISION:
14789 case INT:
14790 case NUMERIC:
14791 case NCHAR:
14792 case NVARCHAR2:
14793 case STRING:
14794 case UROWID:
14795 case VARRAY:
14796 case VARYING:
14797 case BFILE:
14798 case BLOB:
14799 case CLOB:
14800 case NCLOB:
14801 case YEAR:
14802 case LOCAL:
14803 case WITH:
14804 case ZONE:
14805 case CHARACTER:
14806 case AFTER:
14807 case BEFORE:
14808 case OLD:
14809 case PARENT:
14810 case CC_IF:
14811 case CC_ERROR:
14812 case ANALYZE:
14813 case ASSOCIATE:
14814 case AUDIT:
14815 case COMPOUND:
14816 case DATABASE:
14817 case CALL:
14818 case DDL:
14819 case DISASSOCIATE:
14820 case EACH:
14821 case FOLLOWS:
14822 case LOGOFF:
14823 case LOGON:
14824 case NESTED:
14825 case NOAUDIT:
14826 case SCHEMA:
14827 case SERVERERROR:
14828 case SHUTDOWN:
14829 case STARTUP:
14830 case STATEMENT:
14831 case STATISTICS:
14832 case SUSPEND:
14833 case TRUNCATE:
14834 case WRAPPED:
14835 case LIBRARY:
14836 case NAME:
14837 case STRUCT:
14838 case CONTEXT:
14839 case PARAMETERS:
14840 case LENGTH:
14841 case TDO:
14842 case MAXLEN:
14843 case CHARSETID:
14844 case CHARSETFORM:
14845 case ACCEPT:
14846 case ACCESSIBLE:
14847 case COPY:
14848 case DEFINE:
14849 case DISCONNECT:
14850 case HOST:
14851 case PRINT:
14852 case QUIT:
14853 case REMARK:
14854 case UNDEFINE:
14855 case VARIABLE:
14856 case WHENEVER:
14857 case ATTACH:
14858 case CAST:
14859 case TREAT:
14860 case TRIM:
14861 case LEFT:
14862 case RIGHT:
14863 case BOTH:
14864 case EMPTY:
14865 case MULTISET:
14866 case SUBMULTISET:
14867 case LEADING:
14868 case TRAILING:
14869 case CHAR_CS:
14870 case NCHAR_CS:
14871 case DBTIMEZONE:
14872 case SESSIONTIMEZONE:
14873 case AUTHENTICATED:
14874 case LINK:
14875 case SHARED:
14876 case DIRECTORY:
14877 case USER:
14878 case IDENTIFIER:
14879 case UNSIGNED_NUMERIC_LITERAL:
14880 case CHARACTER_LITERAL:
14881 case STRING_LITERAL:
14882 case QUOTED_LITERAL:
14883 ;
14884 break;
14885 default:
14886 jj_la1[171] = jj_gen;
14887 break label_39;
14888 }
14889 Statement();
14890 }
14891 label_40:
14892 while (true) {
14893 switch (jj_nt.kind) {
14894 case CC_ELSIF:
14895 ;
14896 break;
14897 default:
14898 jj_la1[172] = jj_gen;
14899 break label_40;
14900 }
14901 jj_consume_token(CC_ELSIF);
14902 ConditionalOrExpression();
14903 jj_consume_token(CC_THEN);
14904 label_41:
14905 while (true) {
14906 Statement();
14907 switch (jj_nt.kind) {
14908 case 5:
14909 case 16:
14910 case 17:
14911 case 21:
14912 case REPLACE:
14913 case DEFINER:
14914 case CURRENT_USER:
14915 case LANGUAGE:
14916 case ADD:
14917 case AGGREGATE:
14918 case ARRAY:
14919 case AT:
14920 case ATTRIBUTE:
14921 case AUTHID:
14922 case BEGIN:
14923 case BODY:
14924 case BULK:
14925 case BYTE:
14926 case CASCADE:
14927 case CASE:
14928 case CLOSE:
14929 case COALESCE:
14930 case COLLECT:
14931 case COLUMN:
14932 case COMMENT:
14933 case COMMIT:
14934 case CONSTRUCTOR:
14935 case CONTINUE:
14936 case CONVERT:
14937 case CURRENT:
14938 case CURSOR:
14939 case DATA:
14940 case DATE:
14941 case DAY:
14942 case DECLARE:
14943 case DELETE:
14944 case DISABLE:
14945 case EDITIONABLE:
14946 case ELEMENT:
14947 case ENABLE:
14948 case ESCAPE:
14949 case EXCEPT:
14950 case EXCEPTIONS:
14951 case EXECUTE:
14952 case EXIT:
14953 case EXTERNAL:
14954 case EXTENDS:
14955 case EXTRACT:
14956 case FALSE:
14957 case FETCH:
14958 case FINAL:
14959 case FOR:
14960 case FORALL:
14961 case FORCE:
14962 case FUNCTION:
14963 case GLOBAL:
14964 case GOTO:
14965 case HASH:
14966 case HEAP:
14967 case HOUR:
14968 case IF:
14969 case IMMEDIATE:
14970 case INDICES:
14971 case INDEXTYPE:
14972 case INDICATOR:
14973 case INSERT:
14974 case INSTANTIABLE:
14975 case INTERVAL:
14976 case INVALIDATE:
14977 case ISOLATION:
14978 case JAVA:
14979 case LEVEL:
14980 case LIMIT:
14981 case LOCK:
14982 case LOOP:
14983 case MAP:
14984 case MAX:
14985 case MEMBER:
14986 case MERGE:
14987 case MIN:
14988 case MINUTE:
14989 case MLSLABEL:
14990 case MODIFY:
14991 case MOD:
14992 case MONTH:
14993 case NATURAL:
14994 case NEW:
14995 case NEW_DOT:
14996 case NO:
14997 case NONEDITIONABLE:
14998 case NOT:
14999 case NULL:
15000 case NULLIF:
15001 case OBJECT:
15002 case OID:
15003 case OPAQUE:
15004 case OPEN:
15005 case OPERATOR:
15006 case ORGANIZATION:
15007 case OTHERS:
15008 case OVERRIDING:
15009 case PACKAGE:
15010 case PARTITION:
15011 case PIPE:
15012 case PRESERVE:
15013 case PRIVATE:
15014 case PROCEDURE:
15015 case RAISE:
15016 case RANGE:
15017 case RAW:
15018 case REAL:
15019 case RECORD:
15020 case REF:
15021 case RELEASE:
15022 case RELIES_ON:
15023 case RENAME:
15024 case RESULT:
15025 case RETURN:
15026 case RETURNING:
15027 case REVERSE:
15028 case ROLLBACK:
15029 case ROW:
15030 case ROWS:
15031 case ROWID:
15032 case ROWNUM:
15033 case SAVE:
15034 case SAVEPOINT:
15035 case SECOND:
15036 case SELECT:
15037 case SELF:
15038 case SET:
15039 case SPACE:
15040 case SQL:
15041 case SQLCODE:
15042 case SQLERRM:
15043 case STATIC:
15044 case SUBTYPE:
15045 case SUBSTITUTABLE:
15046 case SUCCESSFUL:
15047 case SYSDATE:
15048 case SYS_REFCURSOR:
15049 case TEMPORARY:
15050 case TIME:
15051 case TIMESTAMP:
15052 case TIMEZONE_REGION:
15053 case TIMEZONE_ABBR:
15054 case TIMEZONE_MINUTE:
15055 case TIMEZONE_HOUR:
15056 case TRANSACTION:
15057 case TRUE:
15058 case TYPE:
15059 case UNDER:
15060 case USING:
15061 case WHILE:
15062 case YES:
15063 case SHOW:
15064 case A:
15065 case UPDATE:
15066 case DOUBLE:
15067 case DEC:
15068 case PRECISION:
15069 case INT:
15070 case NUMERIC:
15071 case NCHAR:
15072 case NVARCHAR2:
15073 case STRING:
15074 case UROWID:
15075 case VARRAY:
15076 case VARYING:
15077 case BFILE:
15078 case BLOB:
15079 case CLOB:
15080 case NCLOB:
15081 case YEAR:
15082 case LOCAL:
15083 case WITH:
15084 case ZONE:
15085 case CHARACTER:
15086 case AFTER:
15087 case BEFORE:
15088 case OLD:
15089 case PARENT:
15090 case CC_IF:
15091 case CC_ERROR:
15092 case ANALYZE:
15093 case ASSOCIATE:
15094 case AUDIT:
15095 case COMPOUND:
15096 case DATABASE:
15097 case CALL:
15098 case DDL:
15099 case DISASSOCIATE:
15100 case EACH:
15101 case FOLLOWS:
15102 case LOGOFF:
15103 case LOGON:
15104 case NESTED:
15105 case NOAUDIT:
15106 case SCHEMA:
15107 case SERVERERROR:
15108 case SHUTDOWN:
15109 case STARTUP:
15110 case STATEMENT:
15111 case STATISTICS:
15112 case SUSPEND:
15113 case TRUNCATE:
15114 case WRAPPED:
15115 case LIBRARY:
15116 case NAME:
15117 case STRUCT:
15118 case CONTEXT:
15119 case PARAMETERS:
15120 case LENGTH:
15121 case TDO:
15122 case MAXLEN:
15123 case CHARSETID:
15124 case CHARSETFORM:
15125 case ACCEPT:
15126 case ACCESSIBLE:
15127 case COPY:
15128 case DEFINE:
15129 case DISCONNECT:
15130 case HOST:
15131 case PRINT:
15132 case QUIT:
15133 case REMARK:
15134 case UNDEFINE:
15135 case VARIABLE:
15136 case WHENEVER:
15137 case ATTACH:
15138 case CAST:
15139 case TREAT:
15140 case TRIM:
15141 case LEFT:
15142 case RIGHT:
15143 case BOTH:
15144 case EMPTY:
15145 case MULTISET:
15146 case SUBMULTISET:
15147 case LEADING:
15148 case TRAILING:
15149 case CHAR_CS:
15150 case NCHAR_CS:
15151 case DBTIMEZONE:
15152 case SESSIONTIMEZONE:
15153 case AUTHENTICATED:
15154 case LINK:
15155 case SHARED:
15156 case DIRECTORY:
15157 case USER:
15158 case IDENTIFIER:
15159 case UNSIGNED_NUMERIC_LITERAL:
15160 case CHARACTER_LITERAL:
15161 case STRING_LITERAL:
15162 case QUOTED_LITERAL:
15163 ;
15164 break;
15165 default:
15166 jj_la1[173] = jj_gen;
15167 break label_41;
15168 }
15169 }
15170 }
15171 label_42:
15172 while (true) {
15173 switch (jj_nt.kind) {
15174 case CC_ELSE:
15175 ;
15176 break;
15177 default:
15178 jj_la1[174] = jj_gen;
15179 break label_42;
15180 }
15181 jj_consume_token(CC_ELSE);
15182 label_43:
15183 while (true) {
15184 Statement();
15185 switch (jj_nt.kind) {
15186 case 5:
15187 case 16:
15188 case 17:
15189 case 21:
15190 case REPLACE:
15191 case DEFINER:
15192 case CURRENT_USER:
15193 case LANGUAGE:
15194 case ADD:
15195 case AGGREGATE:
15196 case ARRAY:
15197 case AT:
15198 case ATTRIBUTE:
15199 case AUTHID:
15200 case BEGIN:
15201 case BODY:
15202 case BULK:
15203 case BYTE:
15204 case CASCADE:
15205 case CASE:
15206 case CLOSE:
15207 case COALESCE:
15208 case COLLECT:
15209 case COLUMN:
15210 case COMMENT:
15211 case COMMIT:
15212 case CONSTRUCTOR:
15213 case CONTINUE:
15214 case CONVERT:
15215 case CURRENT:
15216 case CURSOR:
15217 case DATA:
15218 case DATE:
15219 case DAY:
15220 case DECLARE:
15221 case DELETE:
15222 case DISABLE:
15223 case EDITIONABLE:
15224 case ELEMENT:
15225 case ENABLE:
15226 case ESCAPE:
15227 case EXCEPT:
15228 case EXCEPTIONS:
15229 case EXECUTE:
15230 case EXIT:
15231 case EXTERNAL:
15232 case EXTENDS:
15233 case EXTRACT:
15234 case FALSE:
15235 case FETCH:
15236 case FINAL:
15237 case FOR:
15238 case FORALL:
15239 case FORCE:
15240 case FUNCTION:
15241 case GLOBAL:
15242 case GOTO:
15243 case HASH:
15244 case HEAP:
15245 case HOUR:
15246 case IF:
15247 case IMMEDIATE:
15248 case INDICES:
15249 case INDEXTYPE:
15250 case INDICATOR:
15251 case INSERT:
15252 case INSTANTIABLE:
15253 case INTERVAL:
15254 case INVALIDATE:
15255 case ISOLATION:
15256 case JAVA:
15257 case LEVEL:
15258 case LIMIT:
15259 case LOCK:
15260 case LOOP:
15261 case MAP:
15262 case MAX:
15263 case MEMBER:
15264 case MERGE:
15265 case MIN:
15266 case MINUTE:
15267 case MLSLABEL:
15268 case MODIFY:
15269 case MOD:
15270 case MONTH:
15271 case NATURAL:
15272 case NEW:
15273 case NEW_DOT:
15274 case NO:
15275 case NONEDITIONABLE:
15276 case NOT:
15277 case NULL:
15278 case NULLIF:
15279 case OBJECT:
15280 case OID:
15281 case OPAQUE:
15282 case OPEN:
15283 case OPERATOR:
15284 case ORGANIZATION:
15285 case OTHERS:
15286 case OVERRIDING:
15287 case PACKAGE:
15288 case PARTITION:
15289 case PIPE:
15290 case PRESERVE:
15291 case PRIVATE:
15292 case PROCEDURE:
15293 case RAISE:
15294 case RANGE:
15295 case RAW:
15296 case REAL:
15297 case RECORD:
15298 case REF:
15299 case RELEASE:
15300 case RELIES_ON:
15301 case RENAME:
15302 case RESULT:
15303 case RETURN:
15304 case RETURNING:
15305 case REVERSE:
15306 case ROLLBACK:
15307 case ROW:
15308 case ROWS:
15309 case ROWID:
15310 case ROWNUM:
15311 case SAVE:
15312 case SAVEPOINT:
15313 case SECOND:
15314 case SELECT:
15315 case SELF:
15316 case SET:
15317 case SPACE:
15318 case SQL:
15319 case SQLCODE:
15320 case SQLERRM:
15321 case STATIC:
15322 case SUBTYPE:
15323 case SUBSTITUTABLE:
15324 case SUCCESSFUL:
15325 case SYSDATE:
15326 case SYS_REFCURSOR:
15327 case TEMPORARY:
15328 case TIME:
15329 case TIMESTAMP:
15330 case TIMEZONE_REGION:
15331 case TIMEZONE_ABBR:
15332 case TIMEZONE_MINUTE:
15333 case TIMEZONE_HOUR:
15334 case TRANSACTION:
15335 case TRUE:
15336 case TYPE:
15337 case UNDER:
15338 case USING:
15339 case WHILE:
15340 case YES:
15341 case SHOW:
15342 case A:
15343 case UPDATE:
15344 case DOUBLE:
15345 case DEC:
15346 case PRECISION:
15347 case INT:
15348 case NUMERIC:
15349 case NCHAR:
15350 case NVARCHAR2:
15351 case STRING:
15352 case UROWID:
15353 case VARRAY:
15354 case VARYING:
15355 case BFILE:
15356 case BLOB:
15357 case CLOB:
15358 case NCLOB:
15359 case YEAR:
15360 case LOCAL:
15361 case WITH:
15362 case ZONE:
15363 case CHARACTER:
15364 case AFTER:
15365 case BEFORE:
15366 case OLD:
15367 case PARENT:
15368 case CC_IF:
15369 case CC_ERROR:
15370 case ANALYZE:
15371 case ASSOCIATE:
15372 case AUDIT:
15373 case COMPOUND:
15374 case DATABASE:
15375 case CALL:
15376 case DDL:
15377 case DISASSOCIATE:
15378 case EACH:
15379 case FOLLOWS:
15380 case LOGOFF:
15381 case LOGON:
15382 case NESTED:
15383 case NOAUDIT:
15384 case SCHEMA:
15385 case SERVERERROR:
15386 case SHUTDOWN:
15387 case STARTUP:
15388 case STATEMENT:
15389 case STATISTICS:
15390 case SUSPEND:
15391 case TRUNCATE:
15392 case WRAPPED:
15393 case LIBRARY:
15394 case NAME:
15395 case STRUCT:
15396 case CONTEXT:
15397 case PARAMETERS:
15398 case LENGTH:
15399 case TDO:
15400 case MAXLEN:
15401 case CHARSETID:
15402 case CHARSETFORM:
15403 case ACCEPT:
15404 case ACCESSIBLE:
15405 case COPY:
15406 case DEFINE:
15407 case DISCONNECT:
15408 case HOST:
15409 case PRINT:
15410 case QUIT:
15411 case REMARK:
15412 case UNDEFINE:
15413 case VARIABLE:
15414 case WHENEVER:
15415 case ATTACH:
15416 case CAST:
15417 case TREAT:
15418 case TRIM:
15419 case LEFT:
15420 case RIGHT:
15421 case BOTH:
15422 case EMPTY:
15423 case MULTISET:
15424 case SUBMULTISET:
15425 case LEADING:
15426 case TRAILING:
15427 case CHAR_CS:
15428 case NCHAR_CS:
15429 case DBTIMEZONE:
15430 case SESSIONTIMEZONE:
15431 case AUTHENTICATED:
15432 case LINK:
15433 case SHARED:
15434 case DIRECTORY:
15435 case USER:
15436 case IDENTIFIER:
15437 case UNSIGNED_NUMERIC_LITERAL:
15438 case CHARACTER_LITERAL:
15439 case STRING_LITERAL:
15440 case QUOTED_LITERAL:
15441 ;
15442 break;
15443 default:
15444 jj_la1[175] = jj_gen;
15445 break label_43;
15446 }
15447 }
15448 }
15449 jj_consume_token(CC_END);
15450 break;
15451 case CC_ERROR:
15452 jj_consume_token(CC_ERROR);
15453 Expression();
15454 jj_consume_token(CC_END);
15455 break;
15456 default:
15457 jj_la1[176] = jj_gen;
15458 jj_consume_token(-1);
15459 throw new ParseException();
15460 }
15461 jjtree.closeNodeScope(jjtn000, true);
15462 jjtc000 = false;
15463 {if (true) return jjtn000 ;}
15464 } catch (Throwable jjte000) {
15465 if (jjtc000) {
15466 jjtree.clearNodeScope(jjtn000);
15467 jjtc000 = false;
15468 } else {
15469 jjtree.popNode();
15470 }
15471 if (jjte000 instanceof RuntimeException) {
15472 {if (true) throw (RuntimeException)jjte000;}
15473 }
15474 if (jjte000 instanceof ParseException) {
15475 {if (true) throw (ParseException)jjte000;}
15476 }
15477 {if (true) throw (Error)jjte000;}
15478 } finally {
15479 if (jjtc000) {
15480 jjtree.closeNodeScope(jjtn000, true);
15481 }
15482 }
15483 throw new Error("Missing return statement in function");
15484 }
15485
15486 final public ASTSubTypeDefinition SubTypeDefinition() throws ParseException {
15487
15488 ASTSubTypeDefinition jjtn000 = new ASTSubTypeDefinition(this, JJTSUBTYPEDEFINITION);
15489 boolean jjtc000 = true;
15490 jjtree.openNodeScope(jjtn000);Token start, subtype_name=null, constraint=null, base_type=null;
15491 Token collection = null, collection2 = null;
15492 PLSQLNode name = null;
15493 PLSQLNode startElement = null, endElement = null;
15494 PLSQLNode baseType = null, returnType = null, indexBy = null ;
15495 int lastField = 0;
15496 try {
15497 switch (jj_nt.kind) {
15498 case SUBTYPE:
15499 jj_consume_token(SUBTYPE);
15500 name = QualifiedID();
15501 jj_consume_token(IS);
15502 Datatype();
15503 switch (jj_nt.kind) {
15504 case 5:
15505 case RANGE:
15506 switch (jj_nt.kind) {
15507 case 5:
15508 jj_consume_token(5);
15509 jj_consume_token(IDENTIFIER);
15510 jj_consume_token(7);
15511 break;
15512 case RANGE:
15513 jj_consume_token(RANGE);
15514 UnaryExpression(true);
15515 jj_consume_token(12);
15516 UnaryExpression(true);
15517 break;
15518 default:
15519 jj_la1[177] = jj_gen;
15520 jj_consume_token(-1);
15521 throw new ParseException();
15522 }
15523 break;
15524 default:
15525 jj_la1[178] = jj_gen;
15526 ;
15527 }
15528 switch (jj_nt.kind) {
15529 case NOT:
15530 jj_consume_token(NOT);
15531 jj_consume_token(NULL);
15532 break;
15533 default:
15534 jj_la1[179] = jj_gen;
15535 ;
15536 }
15537 break;
15538 case TYPE:
15539 jj_consume_token(TYPE);
15540 name = QualifiedID();
15541 switch (jj_nt.kind) {
15542 case IS:
15543 jj_consume_token(IS);
15544 break;
15545 case AS:
15546 jj_consume_token(AS);
15547 break;
15548 default:
15549 jj_la1[180] = jj_gen;
15550 jj_consume_token(-1);
15551 throw new ParseException();
15552 }
15553 if (jj_2_44(2)) {
15554 jj_consume_token(NEW);
15555 switch (jj_nt.kind) {
15556 case CHAR_BASE:
15557 jj_consume_token(CHAR_BASE);
15558 break;
15559 case DATE_BASE:
15560 jj_consume_token(DATE_BASE);
15561 break;
15562 case CLOB_BASE:
15563 jj_consume_token(CLOB_BASE);
15564 break;
15565 case BLOB_BASE:
15566 jj_consume_token(BLOB_BASE);
15567 break;
15568 case BFILE_BASE:
15569 jj_consume_token(BFILE_BASE);
15570 break;
15571 case NUMBER_BASE:
15572 jj_consume_token(NUMBER_BASE);
15573 break;
15574 default:
15575 jj_la1[181] = jj_gen;
15576 jj_consume_token(-1);
15577 throw new ParseException();
15578 }
15579 } else {
15580 switch (jj_nt.kind) {
15581 case OBJECT:
15582 jj_consume_token(OBJECT);
15583 jj_consume_token(5);
15584 FieldDeclaration();
15585 label_44:
15586 while (true) {
15587 switch (jj_nt.kind) {
15588 case 6:
15589 ;
15590 break;
15591 default:
15592 jj_la1[182] = jj_gen;
15593 break label_44;
15594 }
15595 jj_consume_token(6);
15596 FieldDeclaration();
15597 }
15598 jj_consume_token(7);
15599 break;
15600 case RECORD:
15601 jj_consume_token(RECORD);
15602 jj_consume_token(5);
15603 FieldDeclaration();
15604 label_45:
15605 while (true) {
15606 switch (jj_nt.kind) {
15607 case 6:
15608 ;
15609 break;
15610 default:
15611 jj_la1[183] = jj_gen;
15612 break label_45;
15613 }
15614 jj_consume_token(6);
15615 FieldDeclaration();
15616 }
15617 jj_consume_token(7);
15618 break;
15619 case TABLE:
15620 case VARRAY:
15621 case VARYING:
15622 switch (jj_nt.kind) {
15623 case TABLE:
15624 jj_consume_token(TABLE);
15625 break;
15626 case VARRAY:
15627 jj_consume_token(VARRAY);
15628 break;
15629 case VARYING:
15630 jj_consume_token(VARYING);
15631 jj_consume_token(ARRAY);
15632 break;
15633 default:
15634 jj_la1[184] = jj_gen;
15635 jj_consume_token(-1);
15636 throw new ParseException();
15637 }
15638 switch (jj_nt.kind) {
15639 case 5:
15640 jj_consume_token(5);
15641 NumericLiteral();
15642 jj_consume_token(7);
15643 break;
15644 default:
15645 jj_la1[185] = jj_gen;
15646 ;
15647 }
15648 jj_consume_token(OF);
15649 Datatype();
15650 switch (jj_nt.kind) {
15651 case NOT:
15652 jj_consume_token(NOT);
15653 jj_consume_token(NULL);
15654 break;
15655 default:
15656 jj_la1[186] = jj_gen;
15657 ;
15658 }
15659 switch (jj_nt.kind) {
15660 case INDEX:
15661 jj_consume_token(INDEX);
15662 jj_consume_token(BY);
15663 Datatype();
15664 break;
15665 default:
15666 jj_la1[187] = jj_gen;
15667 ;
15668 }
15669 break;
15670 case REF:
15671 jj_consume_token(REF);
15672 jj_consume_token(CURSOR);
15673 switch (jj_nt.kind) {
15674 case RETURN:
15675 jj_consume_token(RETURN);
15676 Datatype();
15677 break;
15678 default:
15679 jj_la1[188] = jj_gen;
15680 ;
15681 }
15682 break;
15683 case 5:
15684 jj_consume_token(5);
15685 Expression();
15686 label_46:
15687 while (true) {
15688 switch (jj_nt.kind) {
15689 case 6:
15690 ;
15691 break;
15692 default:
15693 jj_la1[189] = jj_gen;
15694 break label_46;
15695 }
15696 jj_consume_token(6);
15697 Expression();
15698 }
15699 jj_consume_token(7);
15700 break;
15701 case REPLACE:
15702 case DEFINER:
15703 case CURRENT_USER:
15704 case LANGUAGE:
15705 case ADD:
15706 case AGGREGATE:
15707 case ARRAY:
15708 case AT:
15709 case ATTRIBUTE:
15710 case AUTHID:
15711 case BINARY_INTEGER:
15712 case BODY:
15713 case BOOLEAN:
15714 case BULK:
15715 case BYTE:
15716 case CASCADE:
15717 case CHAR:
15718 case CHAR_BASE:
15719 case CLOSE:
15720 case COALESCE:
15721 case COLLECT:
15722 case COLUMN:
15723 case COMMENT:
15724 case COMMIT:
15725 case CONSTRUCTOR:
15726 case CONTINUE:
15727 case CONVERT:
15728 case CURRENT:
15729 case CURSOR:
15730 case DATA:
15731 case DATE:
15732 case DAY:
15733 case DECIMAL:
15734 case DISABLE:
15735 case EDITIONABLE:
15736 case ELEMENT:
15737 case ENABLE:
15738 case ESCAPE:
15739 case EXCEPT:
15740 case EXCEPTIONS:
15741 case EXIT:
15742 case EXTERNAL:
15743 case EXTENDS:
15744 case EXTRACT:
15745 case FALSE:
15746 case FINAL:
15747 case FLOAT:
15748 case FORCE:
15749 case FUNCTION:
15750 case GLOBAL:
15751 case HASH:
15752 case HEAP:
15753 case HOUR:
15754 case IMMEDIATE:
15755 case INDICES:
15756 case INDEXTYPE:
15757 case INDICATOR:
15758 case INSTANTIABLE:
15759 case INTEGER:
15760 case INTERVAL:
15761 case INVALIDATE:
15762 case ISOLATION:
15763 case JAVA:
15764 case LEVEL:
15765 case LIMIT:
15766 case LONG:
15767 case LOOP:
15768 case MAP:
15769 case MAX:
15770 case MEMBER:
15771 case MERGE:
15772 case MIN:
15773 case MINUTE:
15774 case MLSLABEL:
15775 case MODIFY:
15776 case MOD:
15777 case MONTH:
15778 case NATURAL:
15779 case NATURALN:
15780 case NEW:
15781 case NO:
15782 case NONEDITIONABLE:
15783 case NULLIF:
15784 case NUMBER:
15785 case BFILE_BASE:
15786 case BLOB_BASE:
15787 case CLOB_BASE:
15788 case DATE_BASE:
15789 case NUMBER_BASE:
15790 case OID:
15791 case OPAQUE:
15792 case OPEN:
15793 case OPERATOR:
15794 case ORGANIZATION:
15795 case OTHERS:
15796 case OVERRIDING:
15797 case PACKAGE:
15798 case PARTITION:
15799 case PLS_INTEGER:
15800 case POSITIVE:
15801 case POSITIVEN:
15802 case PRESERVE:
15803 case PRIVATE:
15804 case PROCEDURE:
15805 case RANGE:
15806 case RAW:
15807 case REAL:
15808 case RELEASE:
15809 case RELIES_ON:
15810 case RENAME:
15811 case RESULT:
15812 case RETURN:
15813 case RETURNING:
15814 case REVERSE:
15815 case ROLLBACK:
15816 case ROW:
15817 case ROWS:
15818 case ROWID:
15819 case ROWNUM:
15820 case SAVE:
15821 case SAVEPOINT:
15822 case SECOND:
15823 case SELF:
15824 case SET:
15825 case SMALLINT:
15826 case SPACE:
15827 case SQL:
15828 case SQLCODE:
15829 case SQLERRM:
15830 case STATIC:
15831 case SUBTYPE:
15832 case SUBSTITUTABLE:
15833 case SUCCESSFUL:
15834 case SYSDATE:
15835 case SYS_REFCURSOR:
15836 case TEMPORARY:
15837 case TIME:
15838 case TIMESTAMP:
15839 case TIMEZONE_REGION:
15840 case TIMEZONE_ABBR:
15841 case TIMEZONE_MINUTE:
15842 case TIMEZONE_HOUR:
15843 case TRANSACTION:
15844 case TRUE:
15845 case TYPE:
15846 case UNDER:
15847 case USING:
15848 case YES:
15849 case SHOW:
15850 case A:
15851 case VARCHAR:
15852 case VARCHAR2:
15853 case DOUBLE:
15854 case DEC:
15855 case PRECISION:
15856 case INT:
15857 case NUMERIC:
15858 case SIGNTYPE:
15859 case NCHAR:
15860 case NVARCHAR2:
15861 case STRING:
15862 case UROWID:
15863 case BFILE:
15864 case BLOB:
15865 case CLOB:
15866 case NCLOB:
15867 case YEAR:
15868 case LOCAL:
15869 case ZONE:
15870 case CHARACTER:
15871 case AFTER:
15872 case BEFORE:
15873 case OLD:
15874 case PARENT:
15875 case CC_IF:
15876 case ANALYZE:
15877 case ASSOCIATE:
15878 case AUDIT:
15879 case COMPOUND:
15880 case DATABASE:
15881 case CALL:
15882 case DDL:
15883 case DISASSOCIATE:
15884 case EACH:
15885 case FOLLOWS:
15886 case LOGOFF:
15887 case LOGON:
15888 case NESTED:
15889 case NOAUDIT:
15890 case SCHEMA:
15891 case SERVERERROR:
15892 case SHUTDOWN:
15893 case STARTUP:
15894 case STATEMENT:
15895 case STATISTICS:
15896 case SUSPEND:
15897 case TRUNCATE:
15898 case WRAPPED:
15899 case LIBRARY:
15900 case NAME:
15901 case STRUCT:
15902 case CONTEXT:
15903 case PARAMETERS:
15904 case LENGTH:
15905 case TDO:
15906 case MAXLEN:
15907 case CHARSETID:
15908 case CHARSETFORM:
15909 case ACCEPT:
15910 case ACCESSIBLE:
15911 case COPY:
15912 case DEFINE:
15913 case DISCONNECT:
15914 case HOST:
15915 case PRINT:
15916 case QUIT:
15917 case REMARK:
15918 case UNDEFINE:
15919 case VARIABLE:
15920 case WHENEVER:
15921 case ATTACH:
15922 case CAST:
15923 case TREAT:
15924 case TRIM:
15925 case LEFT:
15926 case RIGHT:
15927 case BOTH:
15928 case EMPTY:
15929 case MULTISET:
15930 case SUBMULTISET:
15931 case LEADING:
15932 case TRAILING:
15933 case CHAR_CS:
15934 case NCHAR_CS:
15935 case DBTIMEZONE:
15936 case SESSIONTIMEZONE:
15937 case AUTHENTICATED:
15938 case LINK:
15939 case SHARED:
15940 case DIRECTORY:
15941 case USER:
15942 case IDENTIFIER:
15943 case QUOTED_LITERAL:
15944 Datatype();
15945 break;
15946 default:
15947 jj_la1[190] = jj_gen;
15948 jj_consume_token(-1);
15949 throw new ParseException();
15950 }
15951 }
15952 break;
15953 default:
15954 jj_la1[191] = jj_gen;
15955 jj_consume_token(-1);
15956 throw new ParseException();
15957 }
15958 jj_consume_token(4);
15959 jjtree.closeNodeScope(jjtn000, true);
15960 jjtc000 = false;
15961 jjtn000.setImage(name.getImage()) ; {if (true) return jjtn000 ;}
15962 } catch (Throwable jjte000) {
15963 if (jjtc000) {
15964 jjtree.clearNodeScope(jjtn000);
15965 jjtc000 = false;
15966 } else {
15967 jjtree.popNode();
15968 }
15969 if (jjte000 instanceof RuntimeException) {
15970 {if (true) throw (RuntimeException)jjte000;}
15971 }
15972 if (jjte000 instanceof ParseException) {
15973 {if (true) throw (ParseException)jjte000;}
15974 }
15975 {if (true) throw (Error)jjte000;}
15976 } finally {
15977 if (jjtc000) {
15978 jjtree.closeNodeScope(jjtn000, true);
15979 }
15980 }
15981 throw new Error("Missing return statement in function");
15982 }
15983
15984 final public ASTFieldDeclaration FieldDeclaration() throws ParseException {
15985
15986 ASTFieldDeclaration jjtn000 = new ASTFieldDeclaration(this, JJTFIELDDECLARATION);
15987 boolean jjtc000 = true;
15988 jjtree.openNodeScope(jjtn000);PLSQLNode name;
15989 PLSQLNode dataType;
15990 PLSQLNode defaultValue = null;
15991 try {
15992 name = ID();
15993 Datatype();
15994 switch (jj_nt.kind) {
15995 case NOT:
15996 case NULL:
15997 switch (jj_nt.kind) {
15998 case NOT:
15999 jj_consume_token(NOT);
16000 break;
16001 default:
16002 jj_la1[192] = jj_gen;
16003 ;
16004 }
16005 jj_consume_token(NULL);
16006 break;
16007 default:
16008 jj_la1[193] = jj_gen;
16009 ;
16010 }
16011 switch (jj_nt.kind) {
16012 case 9:
16013 case _DEFAULT:
16014 switch (jj_nt.kind) {
16015 case 9:
16016 jj_consume_token(9);
16017 jj_consume_token(10);
16018 break;
16019 case _DEFAULT:
16020 jj_consume_token(_DEFAULT);
16021 break;
16022 default:
16023 jj_la1[194] = jj_gen;
16024 jj_consume_token(-1);
16025 throw new ParseException();
16026 }
16027 Expression();
16028 break;
16029 default:
16030 jj_la1[195] = jj_gen;
16031 ;
16032 }
16033 jjtree.closeNodeScope(jjtn000, true);
16034 jjtc000 = false;
16035 jjtn000.setImage(name.getImage()) ; {if (true) return jjtn000 ;}
16036 } catch (Throwable jjte000) {
16037 if (jjtc000) {
16038 jjtree.clearNodeScope(jjtn000);
16039 jjtc000 = false;
16040 } else {
16041 jjtree.popNode();
16042 }
16043 if (jjte000 instanceof RuntimeException) {
16044 {if (true) throw (RuntimeException)jjte000;}
16045 }
16046 if (jjte000 instanceof ParseException) {
16047 {if (true) throw (ParseException)jjte000;}
16048 }
16049 {if (true) throw (Error)jjte000;}
16050 } finally {
16051 if (jjtc000) {
16052 jjtree.closeNodeScope(jjtn000, true);
16053 }
16054 }
16055 throw new Error("Missing return statement in function");
16056 }
16057
16058 final public ASTCollectionTypeDefinition CollectionTypeDefinition() throws ParseException {
16059
16060 ASTCollectionTypeDefinition jjtn000 = new ASTCollectionTypeDefinition(this, JJTCOLLECTIONTYPEDEFINITION);
16061 boolean jjtc000 = true;
16062 jjtree.openNodeScope(jjtn000);Token t = null ;
16063 try {
16064 t = jj_consume_token(IDENTIFIER);
16065 jjtree.closeNodeScope(jjtn000, true);
16066 jjtc000 = false;
16067 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16068 } finally {
16069 if (jjtc000) {
16070 jjtree.closeNodeScope(jjtn000, true);
16071 }
16072 }
16073 throw new Error("Missing return statement in function");
16074 }
16075
16076 final public ASTCollectionDeclaration CollectionDeclaration() throws ParseException {
16077
16078 ASTCollectionDeclaration jjtn000 = new ASTCollectionDeclaration(this, JJTCOLLECTIONDECLARATION);
16079 boolean jjtc000 = true;
16080 jjtree.openNodeScope(jjtn000);Token t = null ;
16081 try {
16082 t = jj_consume_token(IDENTIFIER);
16083 jjtree.closeNodeScope(jjtn000, true);
16084 jjtc000 = false;
16085 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16086 } finally {
16087 if (jjtc000) {
16088 jjtree.closeNodeScope(jjtn000, true);
16089 }
16090 }
16091 throw new Error("Missing return statement in function");
16092 }
16093
16094 final public ASTObjectDeclaration ObjectDeclaration() throws ParseException {
16095
16096 ASTObjectDeclaration jjtn000 = new ASTObjectDeclaration(this, JJTOBJECTDECLARATION);
16097 boolean jjtc000 = true;
16098 jjtree.openNodeScope(jjtn000);Token t = null ;
16099 try {
16100 t = jj_consume_token(IDENTIFIER);
16101 jjtree.closeNodeScope(jjtn000, true);
16102 jjtc000 = false;
16103 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
16104 } finally {
16105 if (jjtc000) {
16106 jjtree.closeNodeScope(jjtn000, true);
16107 }
16108 }
16109 throw new Error("Missing return statement in function");
16110 }
16111
16112
16113 final public ASTCallSpecTail CallSpecTail() throws ParseException {
16114
16115 ASTCallSpecTail jjtn000 = new ASTCallSpecTail(this, JJTCALLSPECTAIL);
16116 boolean jjtc000 = true;
16117 jjtree.openNodeScope(jjtn000);
16118 try {
16119 switch (jj_nt.kind) {
16120 case EXTERNAL:
16121 jj_consume_token(EXTERNAL);
16122 break;
16123 case LANGUAGE:
16124 jj_consume_token(LANGUAGE);
16125 switch (jj_nt.kind) {
16126 case IDENTIFIER:
16127 jj_consume_token(IDENTIFIER);
16128 break;
16129 case JAVA:
16130 jj_consume_token(JAVA);
16131 break;
16132 default:
16133 jj_la1[196] = jj_gen;
16134 jj_consume_token(-1);
16135 throw new ParseException();
16136 }
16137 break;
16138 default:
16139 jj_la1[197] = jj_gen;
16140 jj_consume_token(-1);
16141 throw new ParseException();
16142 }
16143 label_47:
16144 while (true) {
16145 switch (jj_nt.kind) {
16146 case WITH:
16147 case LIBRARY:
16148 case NAME:
16149 case PARAMETERS:
16150 ;
16151 break;
16152 default:
16153 jj_la1[198] = jj_gen;
16154 break label_47;
16155 }
16156 switch (jj_nt.kind) {
16157 case LIBRARY:
16158 jj_consume_token(LIBRARY);
16159 switch (jj_nt.kind) {
16160 case IDENTIFIER:
16161 jj_consume_token(IDENTIFIER);
16162 break;
16163 case QUOTED_LITERAL:
16164 jj_consume_token(QUOTED_LITERAL);
16165 break;
16166 case STRING_LITERAL:
16167 StringLiteral();
16168 break;
16169 default:
16170 jj_la1[199] = jj_gen;
16171 jj_consume_token(-1);
16172 throw new ParseException();
16173 }
16174 switch (jj_nt.kind) {
16175 case 3:
16176 jj_consume_token(3);
16177 switch (jj_nt.kind) {
16178 case IDENTIFIER:
16179 jj_consume_token(IDENTIFIER);
16180 break;
16181 case QUOTED_LITERAL:
16182 jj_consume_token(QUOTED_LITERAL);
16183 break;
16184 case STRING_LITERAL:
16185 StringLiteral();
16186 break;
16187 default:
16188 jj_la1[200] = jj_gen;
16189 jj_consume_token(-1);
16190 throw new ParseException();
16191 }
16192 break;
16193 default:
16194 jj_la1[201] = jj_gen;
16195 ;
16196 }
16197 break;
16198 case NAME:
16199 jj_consume_token(NAME);
16200 switch (jj_nt.kind) {
16201 case IDENTIFIER:
16202 jj_consume_token(IDENTIFIER);
16203 break;
16204 case QUOTED_LITERAL:
16205 jj_consume_token(QUOTED_LITERAL);
16206 break;
16207 case STRING_LITERAL:
16208 StringLiteral();
16209 break;
16210 default:
16211 jj_la1[202] = jj_gen;
16212 jj_consume_token(-1);
16213 throw new ParseException();
16214 }
16215 break;
16216 case WITH:
16217 jj_consume_token(WITH);
16218 jj_consume_token(CONTEXT);
16219 break;
16220 case PARAMETERS:
16221 jj_consume_token(PARAMETERS);
16222 SkipPastNextOccurrence(")");
16223 break;
16224 default:
16225 jj_la1[203] = jj_gen;
16226 jj_consume_token(-1);
16227 throw new ParseException();
16228 }
16229 }
16230 jjtree.closeNodeScope(jjtn000, true);
16231 jjtc000 = false;
16232 {if (true) return jjtn000 ;}
16233 } catch (Throwable jjte000) {
16234 if (jjtc000) {
16235 jjtree.clearNodeScope(jjtn000);
16236 jjtc000 = false;
16237 } else {
16238 jjtree.popNode();
16239 }
16240 if (jjte000 instanceof RuntimeException) {
16241 {if (true) throw (RuntimeException)jjte000;}
16242 }
16243 if (jjte000 instanceof ParseException) {
16244 {if (true) throw (ParseException)jjte000;}
16245 }
16246 {if (true) throw (Error)jjte000;}
16247 } finally {
16248 if (jjtc000) {
16249 jjtree.closeNodeScope(jjtn000, true);
16250 }
16251 }
16252 throw new Error("Missing return statement in function");
16253 }
16254
16255
16256 final public ASTCursorUnit CursorUnit() throws ParseException {
16257
16258 ASTCursorUnit jjtn000 = new ASTCursorUnit(this, JJTCURSORUNIT);
16259 boolean jjtc000 = true;
16260 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
16261 try {
16262 jj_consume_token(CURSOR);
16263 simpleNode = ID();
16264 switch (jj_nt.kind) {
16265 case 5:
16266 FormalParameters();
16267 break;
16268 default:
16269 jj_la1[204] = jj_gen;
16270 ;
16271 }
16272 switch (jj_nt.kind) {
16273 case RETURN:
16274 jj_consume_token(RETURN);
16275 Datatype();
16276 break;
16277 default:
16278 jj_la1[205] = jj_gen;
16279 ;
16280 }
16281 switch (jj_nt.kind) {
16282 case IS:
16283 jj_consume_token(IS);
16284 label_48:
16285 while (true) {
16286 switch (jj_nt.kind) {
16287 case 5:
16288 ;
16289 break;
16290 default:
16291 jj_la1[206] = jj_gen;
16292 break label_48;
16293 }
16294 jj_consume_token(5);
16295 }
16296 SqlStatement(null,";");
16297 break;
16298 default:
16299 jj_la1[207] = jj_gen;
16300 ;
16301 }
16302 jj_consume_token(4);
16303 jjtree.closeNodeScope(jjtn000, true);
16304 jjtc000 = false;
16305 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
16306 } catch (Throwable jjte000) {
16307 if (jjtc000) {
16308 jjtree.clearNodeScope(jjtn000);
16309 jjtc000 = false;
16310 } else {
16311 jjtree.popNode();
16312 }
16313 if (jjte000 instanceof RuntimeException) {
16314 {if (true) throw (RuntimeException)jjte000;}
16315 }
16316 if (jjte000 instanceof ParseException) {
16317 {if (true) throw (ParseException)jjte000;}
16318 }
16319 {if (true) throw (Error)jjte000;}
16320 } finally {
16321 if (jjtc000) {
16322 jjtree.closeNodeScope(jjtn000, true);
16323 }
16324 }
16325 throw new Error("Missing return statement in function");
16326 }
16327
16328 final public ASTCursorSpecification CursorSpecification() throws ParseException {
16329
16330 ASTCursorSpecification jjtn000 = new ASTCursorSpecification(this, JJTCURSORSPECIFICATION);
16331 boolean jjtc000 = true;
16332 jjtree.openNodeScope(jjtn000);
16333 try {
16334 CursorUnit();
16335 jjtree.closeNodeScope(jjtn000, true);
16336 jjtc000 = false;
16337 {if (true) return jjtn000 ;}
16338 } catch (Throwable jjte000) {
16339 if (jjtc000) {
16340 jjtree.clearNodeScope(jjtn000);
16341 jjtc000 = false;
16342 } else {
16343 jjtree.popNode();
16344 }
16345 if (jjte000 instanceof RuntimeException) {
16346 {if (true) throw (RuntimeException)jjte000;}
16347 }
16348 if (jjte000 instanceof ParseException) {
16349 {if (true) throw (ParseException)jjte000;}
16350 }
16351 {if (true) throw (Error)jjte000;}
16352 } finally {
16353 if (jjtc000) {
16354 jjtree.closeNodeScope(jjtn000, true);
16355 }
16356 }
16357 throw new Error("Missing return statement in function");
16358 }
16359
16360 final public ASTCursorBody CursorBody() throws ParseException {
16361
16362 ASTCursorBody jjtn000 = new ASTCursorBody(this, JJTCURSORBODY);
16363 boolean jjtc000 = true;
16364 jjtree.openNodeScope(jjtn000);
16365 try {
16366 CursorUnit();
16367 jjtree.closeNodeScope(jjtn000, true);
16368 jjtc000 = false;
16369 {if (true) return jjtn000 ;}
16370 } catch (Throwable jjte000) {
16371 if (jjtc000) {
16372 jjtree.clearNodeScope(jjtn000);
16373 jjtc000 = false;
16374 } else {
16375 jjtree.popNode();
16376 }
16377 if (jjte000 instanceof RuntimeException) {
16378 {if (true) throw (RuntimeException)jjte000;}
16379 }
16380 if (jjte000 instanceof ParseException) {
16381 {if (true) throw (ParseException)jjte000;}
16382 }
16383 {if (true) throw (Error)jjte000;}
16384 } finally {
16385 if (jjtc000) {
16386 jjtree.closeNodeScope(jjtn000, true);
16387 }
16388 }
16389 throw new Error("Missing return statement in function");
16390 }
16391
16392
16393
16394
16395
16396
16397
16398
16399
16400
16401
16402
16403
16404 final public ASTExpression Expression() throws ParseException {
16405
16406 ASTExpression jjtn000 = new ASTExpression(this, JJTEXPRESSION);
16407 boolean jjtc000 = true;
16408 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16409 StringBuilder sb = new StringBuilder() ;
16410 try {
16411 if (jj_2_45(2147483647)) {
16412 simpleNode = Assignment();
16413 sb.append(simpleNode.getImage());
16414 } else {
16415 switch (jj_nt.kind) {
16416 case 5:
16417 case 16:
16418 case 17:
16419 case REPLACE:
16420 case DEFINER:
16421 case CURRENT_USER:
16422 case LANGUAGE:
16423 case ADD:
16424 case AGGREGATE:
16425 case ARRAY:
16426 case AT:
16427 case ATTRIBUTE:
16428 case AUTHID:
16429 case BODY:
16430 case BULK:
16431 case BYTE:
16432 case CASCADE:
16433 case CASE:
16434 case CLOSE:
16435 case COALESCE:
16436 case COLLECT:
16437 case COLUMN:
16438 case COMMENT:
16439 case COMMIT:
16440 case CONSTRUCTOR:
16441 case CONTINUE:
16442 case CONVERT:
16443 case CURRENT:
16444 case CURSOR:
16445 case DATA:
16446 case DATE:
16447 case DAY:
16448 case DISABLE:
16449 case EDITIONABLE:
16450 case ELEMENT:
16451 case ENABLE:
16452 case ESCAPE:
16453 case EXCEPT:
16454 case EXCEPTIONS:
16455 case EXIT:
16456 case EXTERNAL:
16457 case EXTENDS:
16458 case EXTRACT:
16459 case FALSE:
16460 case FINAL:
16461 case FORCE:
16462 case FUNCTION:
16463 case GLOBAL:
16464 case HASH:
16465 case HEAP:
16466 case HOUR:
16467 case IMMEDIATE:
16468 case INDICES:
16469 case INDEXTYPE:
16470 case INDICATOR:
16471 case INSTANTIABLE:
16472 case INTERVAL:
16473 case INVALIDATE:
16474 case ISOLATION:
16475 case JAVA:
16476 case LEVEL:
16477 case LIMIT:
16478 case LOOP:
16479 case MAP:
16480 case MAX:
16481 case MEMBER:
16482 case MERGE:
16483 case MIN:
16484 case MINUTE:
16485 case MLSLABEL:
16486 case MODIFY:
16487 case MOD:
16488 case MONTH:
16489 case NATURAL:
16490 case NEW:
16491 case NEW_DOT:
16492 case NO:
16493 case NONEDITIONABLE:
16494 case NOT:
16495 case NULL:
16496 case NULLIF:
16497 case OBJECT:
16498 case OID:
16499 case OPAQUE:
16500 case OPEN:
16501 case OPERATOR:
16502 case ORGANIZATION:
16503 case OTHERS:
16504 case OVERRIDING:
16505 case PACKAGE:
16506 case PARTITION:
16507 case PRESERVE:
16508 case PRIVATE:
16509 case PROCEDURE:
16510 case RANGE:
16511 case RAW:
16512 case REAL:
16513 case RECORD:
16514 case REF:
16515 case RELEASE:
16516 case RELIES_ON:
16517 case RENAME:
16518 case RESULT:
16519 case RETURN:
16520 case RETURNING:
16521 case REVERSE:
16522 case ROLLBACK:
16523 case ROW:
16524 case ROWS:
16525 case ROWID:
16526 case ROWNUM:
16527 case SAVE:
16528 case SAVEPOINT:
16529 case SECOND:
16530 case SELECT:
16531 case SELF:
16532 case SET:
16533 case SPACE:
16534 case SQL:
16535 case SQLCODE:
16536 case SQLERRM:
16537 case STATIC:
16538 case SUBTYPE:
16539 case SUBSTITUTABLE:
16540 case SUCCESSFUL:
16541 case SYSDATE:
16542 case SYS_REFCURSOR:
16543 case TEMPORARY:
16544 case TIME:
16545 case TIMESTAMP:
16546 case TIMEZONE_REGION:
16547 case TIMEZONE_ABBR:
16548 case TIMEZONE_MINUTE:
16549 case TIMEZONE_HOUR:
16550 case TRANSACTION:
16551 case TRUE:
16552 case TYPE:
16553 case UNDER:
16554 case USING:
16555 case YES:
16556 case SHOW:
16557 case A:
16558 case DOUBLE:
16559 case DEC:
16560 case PRECISION:
16561 case INT:
16562 case NUMERIC:
16563 case NCHAR:
16564 case NVARCHAR2:
16565 case STRING:
16566 case UROWID:
16567 case VARRAY:
16568 case VARYING:
16569 case BFILE:
16570 case BLOB:
16571 case CLOB:
16572 case NCLOB:
16573 case YEAR:
16574 case LOCAL:
16575 case WITH:
16576 case ZONE:
16577 case CHARACTER:
16578 case AFTER:
16579 case BEFORE:
16580 case OLD:
16581 case PARENT:
16582 case ANALYZE:
16583 case ASSOCIATE:
16584 case AUDIT:
16585 case COMPOUND:
16586 case DATABASE:
16587 case CALL:
16588 case DDL:
16589 case DISASSOCIATE:
16590 case EACH:
16591 case FOLLOWS:
16592 case LOGOFF:
16593 case LOGON:
16594 case NESTED:
16595 case NOAUDIT:
16596 case SCHEMA:
16597 case SERVERERROR:
16598 case SHUTDOWN:
16599 case STARTUP:
16600 case STATEMENT:
16601 case STATISTICS:
16602 case SUSPEND:
16603 case TRUNCATE:
16604 case WRAPPED:
16605 case LIBRARY:
16606 case NAME:
16607 case STRUCT:
16608 case CONTEXT:
16609 case PARAMETERS:
16610 case LENGTH:
16611 case TDO:
16612 case MAXLEN:
16613 case CHARSETID:
16614 case CHARSETFORM:
16615 case ACCEPT:
16616 case ACCESSIBLE:
16617 case COPY:
16618 case DEFINE:
16619 case DISCONNECT:
16620 case HOST:
16621 case PRINT:
16622 case QUIT:
16623 case REMARK:
16624 case UNDEFINE:
16625 case VARIABLE:
16626 case WHENEVER:
16627 case ATTACH:
16628 case CAST:
16629 case TREAT:
16630 case TRIM:
16631 case LEFT:
16632 case RIGHT:
16633 case BOTH:
16634 case EMPTY:
16635 case MULTISET:
16636 case SUBMULTISET:
16637 case LEADING:
16638 case TRAILING:
16639 case CHAR_CS:
16640 case NCHAR_CS:
16641 case DBTIMEZONE:
16642 case SESSIONTIMEZONE:
16643 case AUTHENTICATED:
16644 case LINK:
16645 case SHARED:
16646 case DIRECTORY:
16647 case USER:
16648 case IDENTIFIER:
16649 case UNSIGNED_NUMERIC_LITERAL:
16650 case CHARACTER_LITERAL:
16651 case STRING_LITERAL:
16652 case QUOTED_LITERAL:
16653 simpleNode = ConditionalOrExpression();
16654 sb.append(simpleNode.getImage());
16655 break;
16656 case CC_IF:
16657 simpleNode = CompilationExpression();
16658 sb.append(simpleNode.getImage());
16659 break;
16660 default:
16661 jj_la1[208] = jj_gen;
16662 jj_consume_token(-1);
16663 throw new ParseException();
16664 }
16665 }
16666 jjtree.closeNodeScope(jjtn000, true);
16667 jjtc000 = false;
16668 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16669 } catch (Throwable jjte000) {
16670 if (jjtc000) {
16671 jjtree.clearNodeScope(jjtn000);
16672 jjtc000 = false;
16673 } else {
16674 jjtree.popNode();
16675 }
16676 if (jjte000 instanceof RuntimeException) {
16677 {if (true) throw (RuntimeException)jjte000;}
16678 }
16679 if (jjte000 instanceof ParseException) {
16680 {if (true) throw (ParseException)jjte000;}
16681 }
16682 {if (true) throw (Error)jjte000;}
16683 } finally {
16684 if (jjtc000) {
16685 jjtree.closeNodeScope(jjtn000, true);
16686 }
16687 }
16688 throw new Error("Missing return statement in function");
16689 }
16690
16691 final public ASTCompilationExpression CompilationExpression() throws ParseException {
16692
16693 ASTCompilationExpression jjtn000 = new ASTCompilationExpression(this, JJTCOMPILATIONEXPRESSION);
16694 boolean jjtc000 = true;
16695 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
16696 StringBuilder sb = new StringBuilder() ;
16697 try {
16698 jj_consume_token(CC_IF);
16699 sb.append(" "); sb.append(token.image) ;
16700 simpleNode = ConditionalOrExpression();
16701 sb.append(" "); sb.append(simpleNode.getImage());
16702 jj_consume_token(CC_THEN);
16703 sb.append(" "); sb.append(token.image);
16704 simpleNode = Expression();
16705 sb.append(" "); sb.append(simpleNode.getImage());
16706 label_49:
16707 while (true) {
16708 switch (jj_nt.kind) {
16709 case CC_ELSIF:
16710 ;
16711 break;
16712 default:
16713 jj_la1[209] = jj_gen;
16714 break label_49;
16715 }
16716 jj_consume_token(CC_ELSIF);
16717 sb.append(" "); sb.append(token.image);
16718 simpleNode = ConditionalOrExpression();
16719 sb.append(" "); sb.append(simpleNode.getImage());
16720 jj_consume_token(CC_THEN);
16721 sb.append(" "); sb.append(token.image);
16722 simpleNode = Expression();
16723 sb.append(" "); sb.append(simpleNode.getImage());
16724 }
16725 label_50:
16726 while (true) {
16727 switch (jj_nt.kind) {
16728 case CC_ELSE:
16729 ;
16730 break;
16731 default:
16732 jj_la1[210] = jj_gen;
16733 break label_50;
16734 }
16735 jj_consume_token(CC_ELSE);
16736 sb.append(" "); sb.append(token.image);
16737 simpleNode = Expression();
16738 sb.append(" "); sb.append(simpleNode.getImage());
16739 }
16740 jj_consume_token(CC_END);
16741 sb.append(" "); sb.append(token.image);
16742 jjtree.closeNodeScope(jjtn000, true);
16743 jjtc000 = false;
16744 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16745 } catch (Throwable jjte000) {
16746 if (jjtc000) {
16747 jjtree.clearNodeScope(jjtn000);
16748 jjtc000 = false;
16749 } else {
16750 jjtree.popNode();
16751 }
16752 if (jjte000 instanceof RuntimeException) {
16753 {if (true) throw (RuntimeException)jjte000;}
16754 }
16755 if (jjte000 instanceof ParseException) {
16756 {if (true) throw (ParseException)jjte000;}
16757 }
16758 {if (true) throw (Error)jjte000;}
16759 } finally {
16760 if (jjtc000) {
16761 jjtree.closeNodeScope(jjtn000, true);
16762 }
16763 }
16764 throw new Error("Missing return statement in function");
16765 }
16766
16767 final public ASTAssignment Assignment() throws ParseException {
16768
16769 ASTAssignment jjtn000 = new ASTAssignment(this, JJTASSIGNMENT);
16770 boolean jjtc000 = true;
16771 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16772 try {
16773 simpleNode = PrimaryExpression();
16774 sb.append(simpleNode.getImage());
16775 jj_consume_token(9);
16776 jj_consume_token(10);
16777 sb.append(" := ");
16778 simpleNode = Expression();
16779 sb.append(simpleNode.getImage());
16780 jjtree.closeNodeScope(jjtn000, true);
16781 jjtc000 = false;
16782 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
16783 } catch (Throwable jjte000) {
16784 if (jjtc000) {
16785 jjtree.clearNodeScope(jjtn000);
16786 jjtc000 = false;
16787 } else {
16788 jjtree.popNode();
16789 }
16790 if (jjte000 instanceof RuntimeException) {
16791 {if (true) throw (RuntimeException)jjte000;}
16792 }
16793 if (jjte000 instanceof ParseException) {
16794 {if (true) throw (ParseException)jjte000;}
16795 }
16796 {if (true) throw (Error)jjte000;}
16797 } finally {
16798 if (jjtc000) {
16799 jjtree.closeNodeScope(jjtn000, true);
16800 }
16801 }
16802 throw new Error("Missing return statement in function");
16803 }
16804
16805 final public ASTCaseExpression CaseExpression() throws ParseException {
16806
16807 ASTCaseExpression jjtn000 = new ASTCaseExpression(this, JJTCASEEXPRESSION);
16808 boolean jjtc000 = true;
16809 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
16810 try {
16811 thisToken = jj_consume_token(CASE);
16812 sb.append(thisToken.image);
16813 switch (jj_nt.kind) {
16814 case 5:
16815 case 16:
16816 case 17:
16817 case REPLACE:
16818 case DEFINER:
16819 case CURRENT_USER:
16820 case LANGUAGE:
16821 case ADD:
16822 case AGGREGATE:
16823 case ARRAY:
16824 case AT:
16825 case ATTRIBUTE:
16826 case AUTHID:
16827 case BODY:
16828 case BULK:
16829 case BYTE:
16830 case CASCADE:
16831 case CASE:
16832 case CLOSE:
16833 case COALESCE:
16834 case COLLECT:
16835 case COLUMN:
16836 case COMMENT:
16837 case COMMIT:
16838 case CONSTRUCTOR:
16839 case CONTINUE:
16840 case CONVERT:
16841 case CURRENT:
16842 case CURSOR:
16843 case DATA:
16844 case DATE:
16845 case DAY:
16846 case DISABLE:
16847 case EDITIONABLE:
16848 case ELEMENT:
16849 case ENABLE:
16850 case ESCAPE:
16851 case EXCEPT:
16852 case EXCEPTIONS:
16853 case EXIT:
16854 case EXTERNAL:
16855 case EXTENDS:
16856 case EXTRACT:
16857 case FALSE:
16858 case FINAL:
16859 case FORCE:
16860 case FUNCTION:
16861 case GLOBAL:
16862 case HASH:
16863 case HEAP:
16864 case HOUR:
16865 case IMMEDIATE:
16866 case INDICES:
16867 case INDEXTYPE:
16868 case INDICATOR:
16869 case INSTANTIABLE:
16870 case INTERVAL:
16871 case INVALIDATE:
16872 case ISOLATION:
16873 case JAVA:
16874 case LEVEL:
16875 case LIMIT:
16876 case LOOP:
16877 case MAP:
16878 case MAX:
16879 case MEMBER:
16880 case MERGE:
16881 case MIN:
16882 case MINUTE:
16883 case MLSLABEL:
16884 case MODIFY:
16885 case MOD:
16886 case MONTH:
16887 case NATURAL:
16888 case NEW:
16889 case NEW_DOT:
16890 case NO:
16891 case NONEDITIONABLE:
16892 case NOT:
16893 case NULL:
16894 case NULLIF:
16895 case OBJECT:
16896 case OID:
16897 case OPAQUE:
16898 case OPEN:
16899 case OPERATOR:
16900 case ORGANIZATION:
16901 case OTHERS:
16902 case OVERRIDING:
16903 case PACKAGE:
16904 case PARTITION:
16905 case PRESERVE:
16906 case PRIVATE:
16907 case PROCEDURE:
16908 case RANGE:
16909 case RAW:
16910 case REAL:
16911 case RECORD:
16912 case REF:
16913 case RELEASE:
16914 case RELIES_ON:
16915 case RENAME:
16916 case RESULT:
16917 case RETURN:
16918 case RETURNING:
16919 case REVERSE:
16920 case ROLLBACK:
16921 case ROW:
16922 case ROWS:
16923 case ROWID:
16924 case ROWNUM:
16925 case SAVE:
16926 case SAVEPOINT:
16927 case SECOND:
16928 case SELECT:
16929 case SELF:
16930 case SET:
16931 case SPACE:
16932 case SQL:
16933 case SQLCODE:
16934 case SQLERRM:
16935 case STATIC:
16936 case SUBTYPE:
16937 case SUBSTITUTABLE:
16938 case SUCCESSFUL:
16939 case SYSDATE:
16940 case SYS_REFCURSOR:
16941 case TEMPORARY:
16942 case TIME:
16943 case TIMESTAMP:
16944 case TIMEZONE_REGION:
16945 case TIMEZONE_ABBR:
16946 case TIMEZONE_MINUTE:
16947 case TIMEZONE_HOUR:
16948 case TRANSACTION:
16949 case TRUE:
16950 case TYPE:
16951 case UNDER:
16952 case USING:
16953 case YES:
16954 case SHOW:
16955 case A:
16956 case DOUBLE:
16957 case DEC:
16958 case PRECISION:
16959 case INT:
16960 case NUMERIC:
16961 case NCHAR:
16962 case NVARCHAR2:
16963 case STRING:
16964 case UROWID:
16965 case VARRAY:
16966 case VARYING:
16967 case BFILE:
16968 case BLOB:
16969 case CLOB:
16970 case NCLOB:
16971 case YEAR:
16972 case LOCAL:
16973 case WITH:
16974 case ZONE:
16975 case CHARACTER:
16976 case AFTER:
16977 case BEFORE:
16978 case OLD:
16979 case PARENT:
16980 case CC_IF:
16981 case ANALYZE:
16982 case ASSOCIATE:
16983 case AUDIT:
16984 case COMPOUND:
16985 case DATABASE:
16986 case CALL:
16987 case DDL:
16988 case DISASSOCIATE:
16989 case EACH:
16990 case FOLLOWS:
16991 case LOGOFF:
16992 case LOGON:
16993 case NESTED:
16994 case NOAUDIT:
16995 case SCHEMA:
16996 case SERVERERROR:
16997 case SHUTDOWN:
16998 case STARTUP:
16999 case STATEMENT:
17000 case STATISTICS:
17001 case SUSPEND:
17002 case TRUNCATE:
17003 case WRAPPED:
17004 case LIBRARY:
17005 case NAME:
17006 case STRUCT:
17007 case CONTEXT:
17008 case PARAMETERS:
17009 case LENGTH:
17010 case TDO:
17011 case MAXLEN:
17012 case CHARSETID:
17013 case CHARSETFORM:
17014 case ACCEPT:
17015 case ACCESSIBLE:
17016 case COPY:
17017 case DEFINE:
17018 case DISCONNECT:
17019 case HOST:
17020 case PRINT:
17021 case QUIT:
17022 case REMARK:
17023 case UNDEFINE:
17024 case VARIABLE:
17025 case WHENEVER:
17026 case ATTACH:
17027 case CAST:
17028 case TREAT:
17029 case TRIM:
17030 case LEFT:
17031 case RIGHT:
17032 case BOTH:
17033 case EMPTY:
17034 case MULTISET:
17035 case SUBMULTISET:
17036 case LEADING:
17037 case TRAILING:
17038 case CHAR_CS:
17039 case NCHAR_CS:
17040 case DBTIMEZONE:
17041 case SESSIONTIMEZONE:
17042 case AUTHENTICATED:
17043 case LINK:
17044 case SHARED:
17045 case DIRECTORY:
17046 case USER:
17047 case IDENTIFIER:
17048 case UNSIGNED_NUMERIC_LITERAL:
17049 case CHARACTER_LITERAL:
17050 case STRING_LITERAL:
17051 case QUOTED_LITERAL:
17052 simpleNode = Expression();
17053 sb.append(" "); sb.append(simpleNode.getImage());
17054 break;
17055 default:
17056 jj_la1[211] = jj_gen;
17057 ;
17058 }
17059 label_51:
17060 while (true) {
17061 thisToken = jj_consume_token(WHEN);
17062 sb.append(" "); sb.append(thisToken.image);
17063 simpleNode = Expression();
17064 sb.append(" "); sb.append(simpleNode.getImage());
17065 thisToken = jj_consume_token(THEN);
17066 sb.append(" "); sb.append(thisToken.image);
17067 Expression();
17068 sb.append(" "); sb.append(simpleNode.getImage());
17069 switch (jj_nt.kind) {
17070 case WHEN:
17071 ;
17072 break;
17073 default:
17074 jj_la1[212] = jj_gen;
17075 break label_51;
17076 }
17077 }
17078 switch (jj_nt.kind) {
17079 case ELSE:
17080 thisToken = jj_consume_token(ELSE);
17081 sb.append(" "); sb.append(thisToken.image);
17082 Expression();
17083 sb.append(" "); sb.append(simpleNode.getImage());
17084 break;
17085 default:
17086 jj_la1[213] = jj_gen;
17087 ;
17088 }
17089 thisToken = jj_consume_token(END);
17090 sb.append(" "); sb.append(thisToken.image);
17091 jjtree.closeNodeScope(jjtn000, true);
17092 jjtc000 = false;
17093 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17094 } catch (Throwable jjte000) {
17095 if (jjtc000) {
17096 jjtree.clearNodeScope(jjtn000);
17097 jjtc000 = false;
17098 } else {
17099 jjtree.popNode();
17100 }
17101 if (jjte000 instanceof RuntimeException) {
17102 {if (true) throw (RuntimeException)jjte000;}
17103 }
17104 if (jjte000 instanceof ParseException) {
17105 {if (true) throw (ParseException)jjte000;}
17106 }
17107 {if (true) throw (Error)jjte000;}
17108 } finally {
17109 if (jjtc000) {
17110 jjtree.closeNodeScope(jjtn000, true);
17111 }
17112 }
17113 throw new Error("Missing return statement in function");
17114 }
17115
17116
17117
17118
17119 final public ASTLikeExpression LikeExpression() throws ParseException {
17120
17121 ASTLikeExpression jjtn000 = new ASTLikeExpression(this, JJTLIKEEXPRESSION);
17122 boolean jjtc000 = true;
17123 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17124 try {
17125 simpleNode = PrimaryExpression();
17126 sb.append(" "); sb.append(simpleNode.getImage());
17127 thisToken = jj_consume_token(LIKE);
17128 sb.append(thisToken.image);
17129 simpleNode = StringExpression();
17130 sb.append(" "); sb.append(simpleNode.getImage());
17131 switch (jj_nt.kind) {
17132 case ESCAPE:
17133 jj_consume_token(ESCAPE);
17134 sb.append(" ESCAPE ");
17135 switch (jj_nt.kind) {
17136 case CHARACTER_LITERAL:
17137 jj_consume_token(CHARACTER_LITERAL);
17138 sb.append(" "); sb.append(token.toString());
17139 break;
17140 case STRING_LITERAL:
17141 simpleNode = StringLiteral();
17142 sb.append(" "); sb.append(simpleNode.getImage());
17143 break;
17144 default:
17145 jj_la1[214] = jj_gen;
17146 jj_consume_token(-1);
17147 throw new ParseException();
17148 }
17149 break;
17150 default:
17151 jj_la1[215] = jj_gen;
17152 ;
17153 }
17154 label_52:
17155 while (true) {
17156 switch (jj_nt.kind) {
17157 case 3:
17158 ;
17159 break;
17160 default:
17161 jj_la1[216] = jj_gen;
17162 break label_52;
17163 }
17164 jj_consume_token(3);
17165 simpleNode = Expression();
17166 sb.append("."); sb.append(simpleNode.getImage());
17167 }
17168 jjtree.closeNodeScope(jjtn000, true);
17169 jjtc000 = false;
17170 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17171 } catch (Throwable jjte000) {
17172 if (jjtc000) {
17173 jjtree.clearNodeScope(jjtn000);
17174 jjtc000 = false;
17175 } else {
17176 jjtree.popNode();
17177 }
17178 if (jjte000 instanceof RuntimeException) {
17179 {if (true) throw (RuntimeException)jjte000;}
17180 }
17181 if (jjte000 instanceof ParseException) {
17182 {if (true) throw (ParseException)jjte000;}
17183 }
17184 {if (true) throw (Error)jjte000;}
17185 } finally {
17186 if (jjtc000) {
17187 jjtree.closeNodeScope(jjtn000, true);
17188 }
17189 }
17190 throw new Error("Missing return statement in function");
17191 }
17192
17193 final public ASTTrimExpression TrimExpression() throws ParseException {
17194
17195 ASTTrimExpression jjtn000 = new ASTTrimExpression(this, JJTTRIMEXPRESSION);
17196 boolean jjtc000 = true;
17197 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17198 try {
17199 thisToken = jj_consume_token(TRIM);
17200 sb.append(thisToken.image);
17201 jj_consume_token(5);
17202 sb.append("(");
17203 switch (jj_nt.kind) {
17204 case BOTH:
17205 case LEADING:
17206 case TRAILING:
17207 switch (jj_nt.kind) {
17208 case LEADING:
17209 jj_consume_token(LEADING);
17210 break;
17211 case TRAILING:
17212 jj_consume_token(TRAILING);
17213 break;
17214 case BOTH:
17215 jj_consume_token(BOTH);
17216 break;
17217 default:
17218 jj_la1[217] = jj_gen;
17219 jj_consume_token(-1);
17220 throw new ParseException();
17221 }
17222 sb.append(" "); sb.append(token.toString());
17223 break;
17224 default:
17225 jj_la1[218] = jj_gen;
17226 ;
17227 }
17228 switch (jj_nt.kind) {
17229 case 5:
17230 case REPLACE:
17231 case DEFINER:
17232 case CURRENT_USER:
17233 case LANGUAGE:
17234 case ADD:
17235 case AGGREGATE:
17236 case ARRAY:
17237 case AT:
17238 case ATTRIBUTE:
17239 case AUTHID:
17240 case BODY:
17241 case BULK:
17242 case BYTE:
17243 case CASCADE:
17244 case CASE:
17245 case CLOSE:
17246 case COALESCE:
17247 case COLLECT:
17248 case COLUMN:
17249 case COMMENT:
17250 case COMMIT:
17251 case CONSTRUCTOR:
17252 case CONTINUE:
17253 case CONVERT:
17254 case CURRENT:
17255 case CURSOR:
17256 case DATA:
17257 case DATE:
17258 case DAY:
17259 case DISABLE:
17260 case EDITIONABLE:
17261 case ELEMENT:
17262 case ENABLE:
17263 case ESCAPE:
17264 case EXCEPT:
17265 case EXCEPTIONS:
17266 case EXIT:
17267 case EXTERNAL:
17268 case EXTENDS:
17269 case EXTRACT:
17270 case FALSE:
17271 case FINAL:
17272 case FORCE:
17273 case FUNCTION:
17274 case GLOBAL:
17275 case HASH:
17276 case HEAP:
17277 case HOUR:
17278 case IMMEDIATE:
17279 case INDICES:
17280 case INDEXTYPE:
17281 case INDICATOR:
17282 case INSTANTIABLE:
17283 case INTERVAL:
17284 case INVALIDATE:
17285 case ISOLATION:
17286 case JAVA:
17287 case LEVEL:
17288 case LIMIT:
17289 case LOOP:
17290 case MAP:
17291 case MAX:
17292 case MEMBER:
17293 case MERGE:
17294 case MIN:
17295 case MINUTE:
17296 case MLSLABEL:
17297 case MODIFY:
17298 case MOD:
17299 case MONTH:
17300 case NATURAL:
17301 case NEW:
17302 case NEW_DOT:
17303 case NO:
17304 case NONEDITIONABLE:
17305 case NULL:
17306 case NULLIF:
17307 case OBJECT:
17308 case OID:
17309 case OPAQUE:
17310 case OPEN:
17311 case OPERATOR:
17312 case ORGANIZATION:
17313 case OTHERS:
17314 case OVERRIDING:
17315 case PACKAGE:
17316 case PARTITION:
17317 case PRESERVE:
17318 case PRIVATE:
17319 case PROCEDURE:
17320 case RANGE:
17321 case RAW:
17322 case REAL:
17323 case RECORD:
17324 case REF:
17325 case RELEASE:
17326 case RELIES_ON:
17327 case RENAME:
17328 case RESULT:
17329 case RETURN:
17330 case RETURNING:
17331 case REVERSE:
17332 case ROLLBACK:
17333 case ROW:
17334 case ROWS:
17335 case ROWID:
17336 case ROWNUM:
17337 case SAVE:
17338 case SAVEPOINT:
17339 case SECOND:
17340 case SELECT:
17341 case SELF:
17342 case SET:
17343 case SPACE:
17344 case SQL:
17345 case SQLCODE:
17346 case SQLERRM:
17347 case STATIC:
17348 case SUBTYPE:
17349 case SUBSTITUTABLE:
17350 case SUCCESSFUL:
17351 case SYSDATE:
17352 case SYS_REFCURSOR:
17353 case TEMPORARY:
17354 case TIME:
17355 case TIMESTAMP:
17356 case TIMEZONE_REGION:
17357 case TIMEZONE_ABBR:
17358 case TIMEZONE_MINUTE:
17359 case TIMEZONE_HOUR:
17360 case TRANSACTION:
17361 case TRUE:
17362 case TYPE:
17363 case UNDER:
17364 case USING:
17365 case YES:
17366 case SHOW:
17367 case A:
17368 case DOUBLE:
17369 case DEC:
17370 case PRECISION:
17371 case INT:
17372 case NUMERIC:
17373 case NCHAR:
17374 case NVARCHAR2:
17375 case STRING:
17376 case UROWID:
17377 case VARRAY:
17378 case VARYING:
17379 case BFILE:
17380 case BLOB:
17381 case CLOB:
17382 case NCLOB:
17383 case YEAR:
17384 case LOCAL:
17385 case WITH:
17386 case ZONE:
17387 case CHARACTER:
17388 case AFTER:
17389 case BEFORE:
17390 case OLD:
17391 case PARENT:
17392 case ANALYZE:
17393 case ASSOCIATE:
17394 case AUDIT:
17395 case COMPOUND:
17396 case DATABASE:
17397 case CALL:
17398 case DDL:
17399 case DISASSOCIATE:
17400 case EACH:
17401 case FOLLOWS:
17402 case LOGOFF:
17403 case LOGON:
17404 case NESTED:
17405 case NOAUDIT:
17406 case SCHEMA:
17407 case SERVERERROR:
17408 case SHUTDOWN:
17409 case STARTUP:
17410 case STATEMENT:
17411 case STATISTICS:
17412 case SUSPEND:
17413 case TRUNCATE:
17414 case WRAPPED:
17415 case LIBRARY:
17416 case NAME:
17417 case STRUCT:
17418 case CONTEXT:
17419 case PARAMETERS:
17420 case LENGTH:
17421 case TDO:
17422 case MAXLEN:
17423 case CHARSETID:
17424 case CHARSETFORM:
17425 case ACCEPT:
17426 case ACCESSIBLE:
17427 case COPY:
17428 case DEFINE:
17429 case DISCONNECT:
17430 case HOST:
17431 case PRINT:
17432 case QUIT:
17433 case REMARK:
17434 case UNDEFINE:
17435 case VARIABLE:
17436 case WHENEVER:
17437 case ATTACH:
17438 case CAST:
17439 case TREAT:
17440 case TRIM:
17441 case LEFT:
17442 case RIGHT:
17443 case BOTH:
17444 case EMPTY:
17445 case MULTISET:
17446 case SUBMULTISET:
17447 case LEADING:
17448 case TRAILING:
17449 case CHAR_CS:
17450 case NCHAR_CS:
17451 case DBTIMEZONE:
17452 case SESSIONTIMEZONE:
17453 case AUTHENTICATED:
17454 case LINK:
17455 case SHARED:
17456 case DIRECTORY:
17457 case USER:
17458 case IDENTIFIER:
17459 case UNSIGNED_NUMERIC_LITERAL:
17460 case CHARACTER_LITERAL:
17461 case STRING_LITERAL:
17462 case QUOTED_LITERAL:
17463 simpleNode = StringExpression();
17464 sb.append(" "); sb.append(simpleNode.getImage());
17465 break;
17466 default:
17467 jj_la1[219] = jj_gen;
17468 ;
17469 }
17470 jj_consume_token(FROM);
17471 sb.append(thisToken.image);
17472 simpleNode = StringExpression();
17473 sb.append(" "); sb.append(simpleNode.getImage());
17474 jj_consume_token(7);
17475 sb.append(")");
17476 jjtree.closeNodeScope(jjtn000, true);
17477 jjtc000 = false;
17478 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17479 } catch (Throwable jjte000) {
17480 if (jjtc000) {
17481 jjtree.clearNodeScope(jjtn000);
17482 jjtc000 = false;
17483 } else {
17484 jjtree.popNode();
17485 }
17486 if (jjte000 instanceof RuntimeException) {
17487 {if (true) throw (RuntimeException)jjte000;}
17488 }
17489 if (jjte000 instanceof ParseException) {
17490 {if (true) throw (ParseException)jjte000;}
17491 }
17492 {if (true) throw (Error)jjte000;}
17493 } finally {
17494 if (jjtc000) {
17495 jjtree.closeNodeScope(jjtn000, true);
17496 }
17497 }
17498 throw new Error("Missing return statement in function");
17499 }
17500
17501
17502
17503
17504
17505 final public ASTObjectExpression ObjectExpression() throws ParseException {
17506
17507 ASTObjectExpression jjtn000 = new ASTObjectExpression(this, JJTOBJECTEXPRESSION);
17508 boolean jjtc000 = true;
17509 jjtree.openNodeScope(jjtn000);Token thisToken; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17510 try {
17511 switch (jj_nt.kind) {
17512 case CAST:
17513 thisToken = jj_consume_token(CAST);
17514 break;
17515 case TREAT:
17516 thisToken = jj_consume_token(TREAT);
17517 break;
17518 default:
17519 jj_la1[220] = jj_gen;
17520 jj_consume_token(-1);
17521 throw new ParseException();
17522 }
17523 sb.append(thisToken.image);
17524 jj_consume_token(5);
17525 sb.append("(");
17526 simpleNode = Expression();
17527 sb.append(" "); sb.append(simpleNode.getImage());
17528 switch (jj_nt.kind) {
17529 case AT:
17530 jj_consume_token(AT);
17531 jj_consume_token(TIME);
17532 jj_consume_token(ZONE);
17533 simpleNode = PrimaryExpression();
17534 sb.append(" AT TIME ZONE "); sb.append(simpleNode.getImage());
17535 break;
17536 default:
17537 jj_la1[221] = jj_gen;
17538 ;
17539 }
17540 jj_consume_token(AS);
17541 sb.append(" AS ");
17542 simpleNode = Datatype();
17543 sb.append(" "); sb.append(simpleNode.getImage());
17544 jj_consume_token(7);
17545 sb.append(")");
17546 label_53:
17547 while (true) {
17548 switch (jj_nt.kind) {
17549 case 3:
17550 ;
17551 break;
17552 default:
17553 jj_la1[222] = jj_gen;
17554 break label_53;
17555 }
17556 jj_consume_token(3);
17557 Expression();
17558 }
17559 jjtree.closeNodeScope(jjtn000, true);
17560 jjtc000 = false;
17561 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17562 } catch (Throwable jjte000) {
17563 if (jjtc000) {
17564 jjtree.clearNodeScope(jjtn000);
17565 jjtc000 = false;
17566 } else {
17567 jjtree.popNode();
17568 }
17569 if (jjte000 instanceof RuntimeException) {
17570 {if (true) throw (RuntimeException)jjte000;}
17571 }
17572 if (jjte000 instanceof ParseException) {
17573 {if (true) throw (ParseException)jjte000;}
17574 }
17575 {if (true) throw (Error)jjte000;}
17576 } finally {
17577 if (jjtc000) {
17578 jjtree.closeNodeScope(jjtn000, true);
17579 }
17580 }
17581 throw new Error("Missing return statement in function");
17582 }
17583
17584 final public ASTConditionalOrExpression ConditionalOrExpression() throws ParseException {
17585
17586 ASTConditionalOrExpression jjtn000 = new ASTConditionalOrExpression(this, JJTCONDITIONALOREXPRESSION);
17587 boolean jjtc000 = true;
17588 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17589 try {
17590 simpleNode = ConditionalAndExpression();
17591 sb.append(simpleNode.getImage());
17592 label_54:
17593 while (true) {
17594 switch (jj_nt.kind) {
17595 case OR:
17596 ;
17597 break;
17598 default:
17599 jj_la1[223] = jj_gen;
17600 break label_54;
17601 }
17602 jj_consume_token(OR);
17603 sb.append(" OR ");
17604 simpleNode = ConditionalAndExpression();
17605 sb.append(simpleNode.getImage());
17606 }
17607 jjtree.closeNodeScope(jjtn000, true);
17608 jjtc000 = false;
17609 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17610 } catch (Throwable jjte000) {
17611 if (jjtc000) {
17612 jjtree.clearNodeScope(jjtn000);
17613 jjtc000 = false;
17614 } else {
17615 jjtree.popNode();
17616 }
17617 if (jjte000 instanceof RuntimeException) {
17618 {if (true) throw (RuntimeException)jjte000;}
17619 }
17620 if (jjte000 instanceof ParseException) {
17621 {if (true) throw (ParseException)jjte000;}
17622 }
17623 {if (true) throw (Error)jjte000;}
17624 } finally {
17625 if (jjtc000) {
17626 jjtree.closeNodeScope(jjtn000, true);
17627 }
17628 }
17629 throw new Error("Missing return statement in function");
17630 }
17631
17632 final public ASTConditionalAndExpression ConditionalAndExpression() throws ParseException {
17633
17634 ASTConditionalAndExpression jjtn000 = new ASTConditionalAndExpression(this, JJTCONDITIONALANDEXPRESSION);
17635 boolean jjtc000 = true;
17636 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17637 try {
17638 simpleNode = EqualityExpression();
17639 sb.append(simpleNode.getImage());
17640 label_55:
17641 while (true) {
17642 switch (jj_nt.kind) {
17643 case AND:
17644 ;
17645 break;
17646 default:
17647 jj_la1[224] = jj_gen;
17648 break label_55;
17649 }
17650 jj_consume_token(AND);
17651 sb.append(" AND ");
17652 simpleNode = EqualityExpression();
17653 sb.append(simpleNode.getImage());
17654 }
17655 jjtree.closeNodeScope(jjtn000, true);
17656 jjtc000 = false;
17657 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17658 } catch (Throwable jjte000) {
17659 if (jjtc000) {
17660 jjtree.clearNodeScope(jjtn000);
17661 jjtc000 = false;
17662 } else {
17663 jjtree.popNode();
17664 }
17665 if (jjte000 instanceof RuntimeException) {
17666 {if (true) throw (RuntimeException)jjte000;}
17667 }
17668 if (jjte000 instanceof ParseException) {
17669 {if (true) throw (ParseException)jjte000;}
17670 }
17671 {if (true) throw (Error)jjte000;}
17672 } finally {
17673 if (jjtc000) {
17674 jjtree.closeNodeScope(jjtn000, true);
17675 }
17676 }
17677 throw new Error("Missing return statement in function");
17678 }
17679
17680 final public ASTEqualityExpression EqualityExpression() throws ParseException {
17681
17682 ASTEqualityExpression jjtn000 = new ASTEqualityExpression(this, JJTEQUALITYEXPRESSION);
17683 boolean jjtc000 = true;
17684 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17685 try {
17686 simpleNode = RelationalExpression();
17687 sb.append(simpleNode.getImage());
17688 label_56:
17689 while (true) {
17690 switch (jj_nt.kind) {
17691 case 10:
17692 case 13:
17693 case IS:
17694 ;
17695 break;
17696 default:
17697 jj_la1[225] = jj_gen;
17698 break label_56;
17699 }
17700 switch (jj_nt.kind) {
17701 case 10:
17702 jj_consume_token(10);
17703 sb.append(" = ");
17704 break;
17705 case 13:
17706 jj_consume_token(13);
17707 jj_consume_token(10);
17708 sb.append(" != ");
17709 break;
17710 case IS:
17711 jj_consume_token(IS);
17712 sb.append(" IS ");
17713 break;
17714 default:
17715 jj_la1[226] = jj_gen;
17716 jj_consume_token(-1);
17717 throw new ParseException();
17718 }
17719 simpleNode = RelationalExpression();
17720 sb.append(simpleNode.getImage());
17721 }
17722 jjtree.closeNodeScope(jjtn000, true);
17723 jjtc000 = false;
17724 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17725 } catch (Throwable jjte000) {
17726 if (jjtc000) {
17727 jjtree.clearNodeScope(jjtn000);
17728 jjtc000 = false;
17729 } else {
17730 jjtree.popNode();
17731 }
17732 if (jjte000 instanceof RuntimeException) {
17733 {if (true) throw (RuntimeException)jjte000;}
17734 }
17735 if (jjte000 instanceof ParseException) {
17736 {if (true) throw (ParseException)jjte000;}
17737 }
17738 {if (true) throw (Error)jjte000;}
17739 } finally {
17740 if (jjtc000) {
17741 jjtree.closeNodeScope(jjtn000, true);
17742 }
17743 }
17744 throw new Error("Missing return statement in function");
17745 }
17746
17747
17748
17749
17750 final public ASTRelationalExpression RelationalExpression() throws ParseException {
17751
17752 ASTRelationalExpression jjtn000 = new ASTRelationalExpression(this, JJTRELATIONALEXPRESSION);
17753 boolean jjtc000 = true;
17754 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17755 try {
17756 simpleNode = AdditiveExpression();
17757 sb.append(simpleNode.getImage());
17758 label_57:
17759 while (true) {
17760 switch (jj_nt.kind) {
17761 case 14:
17762 case 15:
17763 case BETWEEN:
17764 case FROM:
17765 case IN:
17766 case LIKE:
17767 case MEMBER:
17768 case NOT:
17769 case MULTISET:
17770 case SUBMULTISET:
17771 ;
17772 break;
17773 default:
17774 jj_la1[227] = jj_gen;
17775 break label_57;
17776 }
17777 switch (jj_nt.kind) {
17778 case 14:
17779 case 15:
17780 switch (jj_nt.kind) {
17781 case 14:
17782 jj_consume_token(14);
17783 sb.append("<");
17784 switch (jj_nt.kind) {
17785 case 15:
17786 jj_consume_token(15);
17787 sb.append(">");
17788 break;
17789 default:
17790 jj_la1[228] = jj_gen;
17791 ;
17792 }
17793 break;
17794 case 15:
17795 jj_consume_token(15);
17796 sb.append(">");
17797 break;
17798 default:
17799 jj_la1[229] = jj_gen;
17800 jj_consume_token(-1);
17801 throw new ParseException();
17802 }
17803 switch (jj_nt.kind) {
17804 case 10:
17805 jj_consume_token(10);
17806 sb.append("=");
17807 break;
17808 default:
17809 jj_la1[230] = jj_gen;
17810 ;
17811 }
17812 sb.append(" ");
17813 break;
17814 case BETWEEN:
17815 case FROM:
17816 case IN:
17817 case LIKE:
17818 case MEMBER:
17819 case NOT:
17820 case SUBMULTISET:
17821 switch (jj_nt.kind) {
17822 case NOT:
17823 jj_consume_token(NOT);
17824 sb.append(" NOT ");
17825 break;
17826 default:
17827 jj_la1[231] = jj_gen;
17828 ;
17829 }
17830 switch (jj_nt.kind) {
17831 case IN:
17832 jj_consume_token(IN);
17833 sb.append(" IN ");
17834 break;
17835 case BETWEEN:
17836 jj_consume_token(BETWEEN);
17837 sb.append(" BETWEEN ");
17838 break;
17839 case LIKE:
17840 jj_consume_token(LIKE);
17841 sb.append(" LIKE ");
17842 break;
17843 case FROM:
17844 jj_consume_token(FROM);
17845 sb.append(" FROM ");
17846 break;
17847 case MEMBER:
17848 case SUBMULTISET:
17849 switch (jj_nt.kind) {
17850 case MEMBER:
17851 jj_consume_token(MEMBER);
17852 sb.append(" MEMBER ");
17853 break;
17854 case SUBMULTISET:
17855 jj_consume_token(SUBMULTISET);
17856 sb.append(" SUBMULTISET ");
17857 break;
17858 default:
17859 jj_la1[232] = jj_gen;
17860 jj_consume_token(-1);
17861 throw new ParseException();
17862 }
17863 switch (jj_nt.kind) {
17864 case OF:
17865 jj_consume_token(OF);
17866 sb.append(" OF ");
17867 break;
17868 default:
17869 jj_la1[233] = jj_gen;
17870 ;
17871 }
17872 break;
17873 default:
17874 jj_la1[234] = jj_gen;
17875 jj_consume_token(-1);
17876 throw new ParseException();
17877 }
17878 break;
17879 case MULTISET:
17880 jj_consume_token(MULTISET);
17881 sb.append (" MULTISET " );
17882 switch (jj_nt.kind) {
17883 case EXCEPT:
17884 jj_consume_token(EXCEPT);
17885 sb.append (" EXCEPT " );
17886 break;
17887 case INTERSECT:
17888 jj_consume_token(INTERSECT);
17889 sb.append (" INTERSECT " );
17890 break;
17891 case UNION:
17892 jj_consume_token(UNION);
17893 sb.append (" UNION " );
17894 break;
17895 default:
17896 jj_la1[235] = jj_gen;
17897 jj_consume_token(-1);
17898 throw new ParseException();
17899 }
17900 switch (jj_nt.kind) {
17901 case ALL:
17902 case DISTINCT:
17903 switch (jj_nt.kind) {
17904 case DISTINCT:
17905 jj_consume_token(DISTINCT);
17906 sb.append (" DISTINCT " );
17907 break;
17908 case ALL:
17909 jj_consume_token(ALL);
17910 sb.append (" ALL " );
17911 break;
17912 default:
17913 jj_la1[236] = jj_gen;
17914 jj_consume_token(-1);
17915 throw new ParseException();
17916 }
17917 break;
17918 default:
17919 jj_la1[237] = jj_gen;
17920 ;
17921 }
17922 break;
17923 default:
17924 jj_la1[238] = jj_gen;
17925 jj_consume_token(-1);
17926 throw new ParseException();
17927 }
17928 AdditiveExpression();
17929 sb.append(simpleNode.getImage());
17930 switch (jj_nt.kind) {
17931 case ESCAPE:
17932 jj_consume_token(ESCAPE);
17933 sb.append(" ESCAPE ");
17934 switch (jj_nt.kind) {
17935 case CHARACTER_LITERAL:
17936 jj_consume_token(CHARACTER_LITERAL);
17937 sb.append(" "); sb.append(token.toString());
17938 break;
17939 case STRING_LITERAL:
17940 simpleNode = StringLiteral();
17941 sb.append(" "); sb.append(simpleNode.getImage());
17942 break;
17943 default:
17944 jj_la1[239] = jj_gen;
17945 jj_consume_token(-1);
17946 throw new ParseException();
17947 }
17948 break;
17949 default:
17950 jj_la1[240] = jj_gen;
17951 ;
17952 }
17953 }
17954 jjtree.closeNodeScope(jjtn000, true);
17955 jjtc000 = false;
17956 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
17957 } catch (Throwable jjte000) {
17958 if (jjtc000) {
17959 jjtree.clearNodeScope(jjtn000);
17960 jjtc000 = false;
17961 } else {
17962 jjtree.popNode();
17963 }
17964 if (jjte000 instanceof RuntimeException) {
17965 {if (true) throw (RuntimeException)jjte000;}
17966 }
17967 if (jjte000 instanceof ParseException) {
17968 {if (true) throw (ParseException)jjte000;}
17969 }
17970 {if (true) throw (Error)jjte000;}
17971 } finally {
17972 if (jjtc000) {
17973 jjtree.closeNodeScope(jjtn000, true);
17974 }
17975 }
17976 throw new Error("Missing return statement in function");
17977 }
17978
17979 final public ASTAdditiveExpression AdditiveExpression() throws ParseException {
17980
17981 ASTAdditiveExpression jjtn000 = new ASTAdditiveExpression(this, JJTADDITIVEEXPRESSION);
17982 boolean jjtc000 = true;
17983 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
17984 try {
17985 simpleNode = MultiplicativeExpression();
17986 sb.append(simpleNode.getImage());
17987 label_58:
17988 while (true) {
17989 switch (jj_nt.kind) {
17990 case 16:
17991 case 17:
17992 case 18:
17993 ;
17994 break;
17995 default:
17996 jj_la1[241] = jj_gen;
17997 break label_58;
17998 }
17999 switch (jj_nt.kind) {
18000 case 16:
18001 jj_consume_token(16);
18002 sb.append(" + ");
18003 break;
18004 case 17:
18005 jj_consume_token(17);
18006 sb.append(" - ");
18007 break;
18008 case 18:
18009 jj_consume_token(18);
18010 sb.append(" || ");
18011 break;
18012 default:
18013 jj_la1[242] = jj_gen;
18014 jj_consume_token(-1);
18015 throw new ParseException();
18016 }
18017 simpleNode = MultiplicativeExpression();
18018 sb.append(simpleNode.getImage());
18019 }
18020 jjtree.closeNodeScope(jjtn000, true);
18021 jjtc000 = false;
18022 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18023 } catch (Throwable jjte000) {
18024 if (jjtc000) {
18025 jjtree.clearNodeScope(jjtn000);
18026 jjtc000 = false;
18027 } else {
18028 jjtree.popNode();
18029 }
18030 if (jjte000 instanceof RuntimeException) {
18031 {if (true) throw (RuntimeException)jjte000;}
18032 }
18033 if (jjte000 instanceof ParseException) {
18034 {if (true) throw (ParseException)jjte000;}
18035 }
18036 {if (true) throw (Error)jjte000;}
18037 } finally {
18038 if (jjtc000) {
18039 jjtree.closeNodeScope(jjtn000, true);
18040 }
18041 }
18042 throw new Error("Missing return statement in function");
18043 }
18044
18045 final public ASTStringExpression StringExpression() throws ParseException {
18046
18047 ASTStringExpression jjtn000 = new ASTStringExpression(this, JJTSTRINGEXPRESSION);
18048 boolean jjtc000 = true;
18049 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18050 try {
18051 simpleNode = PrimaryExpression();
18052 sb.append(simpleNode.getImage());
18053 label_59:
18054 while (true) {
18055 switch (jj_nt.kind) {
18056 case 18:
18057 ;
18058 break;
18059 default:
18060 jj_la1[243] = jj_gen;
18061 break label_59;
18062 }
18063 jj_consume_token(18);
18064 sb.append(" || ");
18065 simpleNode = PrimaryExpression();
18066 sb.append(simpleNode.getImage());
18067 }
18068 jjtree.closeNodeScope(jjtn000, true);
18069 jjtc000 = false;
18070 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18071 } catch (Throwable jjte000) {
18072 if (jjtc000) {
18073 jjtree.clearNodeScope(jjtn000);
18074 jjtc000 = false;
18075 } else {
18076 jjtree.popNode();
18077 }
18078 if (jjte000 instanceof RuntimeException) {
18079 {if (true) throw (RuntimeException)jjte000;}
18080 }
18081 if (jjte000 instanceof ParseException) {
18082 {if (true) throw (ParseException)jjte000;}
18083 }
18084 {if (true) throw (Error)jjte000;}
18085 } finally {
18086 if (jjtc000) {
18087 jjtree.closeNodeScope(jjtn000, true);
18088 }
18089 }
18090 throw new Error("Missing return statement in function");
18091 }
18092
18093 final public ASTMultiplicativeExpression MultiplicativeExpression() throws ParseException {
18094
18095 ASTMultiplicativeExpression jjtn000 = new ASTMultiplicativeExpression(this, JJTMULTIPLICATIVEEXPRESSION);
18096 boolean jjtc000 = true;
18097 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18098 try {
18099 simpleNode = UnaryExpression(true);
18100 sb.append(simpleNode.getImage());
18101 label_60:
18102 while (true) {
18103 switch (jj_nt.kind) {
18104 case 1:
18105 case 19:
18106 case 20:
18107 case MOD:
18108 ;
18109 break;
18110 default:
18111 jj_la1[244] = jj_gen;
18112 break label_60;
18113 }
18114 switch (jj_nt.kind) {
18115 case 19:
18116 jj_consume_token(19);
18117 sb.append(" ** ");
18118 break;
18119 case 20:
18120 jj_consume_token(20);
18121 sb.append(" * ");
18122 break;
18123 case 1:
18124 jj_consume_token(1);
18125 sb.append(" / ");
18126 break;
18127 case MOD:
18128 jj_consume_token(MOD);
18129 sb.append(" MOD ");
18130 break;
18131 default:
18132 jj_la1[245] = jj_gen;
18133 jj_consume_token(-1);
18134 throw new ParseException();
18135 }
18136 simpleNode = UnaryExpression(true);
18137 sb.append(simpleNode.getImage());
18138 }
18139 jjtree.closeNodeScope(jjtn000, true);
18140 jjtc000 = false;
18141 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18142 } catch (Throwable jjte000) {
18143 if (jjtc000) {
18144 jjtree.clearNodeScope(jjtn000);
18145 jjtc000 = false;
18146 } else {
18147 jjtree.popNode();
18148 }
18149 if (jjte000 instanceof RuntimeException) {
18150 {if (true) throw (RuntimeException)jjte000;}
18151 }
18152 if (jjte000 instanceof ParseException) {
18153 {if (true) throw (ParseException)jjte000;}
18154 }
18155 {if (true) throw (Error)jjte000;}
18156 } finally {
18157 if (jjtc000) {
18158 jjtree.closeNodeScope(jjtn000, true);
18159 }
18160 }
18161 throw new Error("Missing return statement in function");
18162 }
18163
18164 final public ASTUnaryExpression UnaryExpression(boolean isUnarySign) throws ParseException {
18165
18166 ASTUnaryExpression jjtn000 = new ASTUnaryExpression(this, JJTUNARYEXPRESSION);
18167 boolean jjtc000 = true;
18168 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18169 try {
18170 switch (jj_nt.kind) {
18171 case 16:
18172 case 17:
18173 switch (jj_nt.kind) {
18174 case 16:
18175 jj_consume_token(16);
18176 sb.append(isUnarySign ? " +" : " + ");
18177 break;
18178 case 17:
18179 jj_consume_token(17);
18180 sb.append(isUnarySign ? " -" : " - ");
18181 break;
18182 default:
18183 jj_la1[246] = jj_gen;
18184 jj_consume_token(-1);
18185 throw new ParseException();
18186 }
18187 simpleNode = UnaryExpression(false);
18188 sb.append(simpleNode.getImage());
18189 break;
18190 case 5:
18191 case REPLACE:
18192 case DEFINER:
18193 case CURRENT_USER:
18194 case LANGUAGE:
18195 case ADD:
18196 case AGGREGATE:
18197 case ARRAY:
18198 case AT:
18199 case ATTRIBUTE:
18200 case AUTHID:
18201 case BODY:
18202 case BULK:
18203 case BYTE:
18204 case CASCADE:
18205 case CASE:
18206 case CLOSE:
18207 case COALESCE:
18208 case COLLECT:
18209 case COLUMN:
18210 case COMMENT:
18211 case COMMIT:
18212 case CONSTRUCTOR:
18213 case CONTINUE:
18214 case CONVERT:
18215 case CURRENT:
18216 case CURSOR:
18217 case DATA:
18218 case DATE:
18219 case DAY:
18220 case DISABLE:
18221 case EDITIONABLE:
18222 case ELEMENT:
18223 case ENABLE:
18224 case ESCAPE:
18225 case EXCEPT:
18226 case EXCEPTIONS:
18227 case EXIT:
18228 case EXTERNAL:
18229 case EXTENDS:
18230 case EXTRACT:
18231 case FALSE:
18232 case FINAL:
18233 case FORCE:
18234 case FUNCTION:
18235 case GLOBAL:
18236 case HASH:
18237 case HEAP:
18238 case HOUR:
18239 case IMMEDIATE:
18240 case INDICES:
18241 case INDEXTYPE:
18242 case INDICATOR:
18243 case INSTANTIABLE:
18244 case INTERVAL:
18245 case INVALIDATE:
18246 case ISOLATION:
18247 case JAVA:
18248 case LEVEL:
18249 case LIMIT:
18250 case LOOP:
18251 case MAP:
18252 case MAX:
18253 case MEMBER:
18254 case MERGE:
18255 case MIN:
18256 case MINUTE:
18257 case MLSLABEL:
18258 case MODIFY:
18259 case MOD:
18260 case MONTH:
18261 case NATURAL:
18262 case NEW:
18263 case NEW_DOT:
18264 case NO:
18265 case NONEDITIONABLE:
18266 case NOT:
18267 case NULL:
18268 case NULLIF:
18269 case OBJECT:
18270 case OID:
18271 case OPAQUE:
18272 case OPEN:
18273 case OPERATOR:
18274 case ORGANIZATION:
18275 case OTHERS:
18276 case OVERRIDING:
18277 case PACKAGE:
18278 case PARTITION:
18279 case PRESERVE:
18280 case PRIVATE:
18281 case PROCEDURE:
18282 case RANGE:
18283 case RAW:
18284 case REAL:
18285 case RECORD:
18286 case REF:
18287 case RELEASE:
18288 case RELIES_ON:
18289 case RENAME:
18290 case RESULT:
18291 case RETURN:
18292 case RETURNING:
18293 case REVERSE:
18294 case ROLLBACK:
18295 case ROW:
18296 case ROWS:
18297 case ROWID:
18298 case ROWNUM:
18299 case SAVE:
18300 case SAVEPOINT:
18301 case SECOND:
18302 case SELECT:
18303 case SELF:
18304 case SET:
18305 case SPACE:
18306 case SQL:
18307 case SQLCODE:
18308 case SQLERRM:
18309 case STATIC:
18310 case SUBTYPE:
18311 case SUBSTITUTABLE:
18312 case SUCCESSFUL:
18313 case SYSDATE:
18314 case SYS_REFCURSOR:
18315 case TEMPORARY:
18316 case TIME:
18317 case TIMESTAMP:
18318 case TIMEZONE_REGION:
18319 case TIMEZONE_ABBR:
18320 case TIMEZONE_MINUTE:
18321 case TIMEZONE_HOUR:
18322 case TRANSACTION:
18323 case TRUE:
18324 case TYPE:
18325 case UNDER:
18326 case USING:
18327 case YES:
18328 case SHOW:
18329 case A:
18330 case DOUBLE:
18331 case DEC:
18332 case PRECISION:
18333 case INT:
18334 case NUMERIC:
18335 case NCHAR:
18336 case NVARCHAR2:
18337 case STRING:
18338 case UROWID:
18339 case VARRAY:
18340 case VARYING:
18341 case BFILE:
18342 case BLOB:
18343 case CLOB:
18344 case NCLOB:
18345 case YEAR:
18346 case LOCAL:
18347 case WITH:
18348 case ZONE:
18349 case CHARACTER:
18350 case AFTER:
18351 case BEFORE:
18352 case OLD:
18353 case PARENT:
18354 case ANALYZE:
18355 case ASSOCIATE:
18356 case AUDIT:
18357 case COMPOUND:
18358 case DATABASE:
18359 case CALL:
18360 case DDL:
18361 case DISASSOCIATE:
18362 case EACH:
18363 case FOLLOWS:
18364 case LOGOFF:
18365 case LOGON:
18366 case NESTED:
18367 case NOAUDIT:
18368 case SCHEMA:
18369 case SERVERERROR:
18370 case SHUTDOWN:
18371 case STARTUP:
18372 case STATEMENT:
18373 case STATISTICS:
18374 case SUSPEND:
18375 case TRUNCATE:
18376 case WRAPPED:
18377 case LIBRARY:
18378 case NAME:
18379 case STRUCT:
18380 case CONTEXT:
18381 case PARAMETERS:
18382 case LENGTH:
18383 case TDO:
18384 case MAXLEN:
18385 case CHARSETID:
18386 case CHARSETFORM:
18387 case ACCEPT:
18388 case ACCESSIBLE:
18389 case COPY:
18390 case DEFINE:
18391 case DISCONNECT:
18392 case HOST:
18393 case PRINT:
18394 case QUIT:
18395 case REMARK:
18396 case UNDEFINE:
18397 case VARIABLE:
18398 case WHENEVER:
18399 case ATTACH:
18400 case CAST:
18401 case TREAT:
18402 case TRIM:
18403 case LEFT:
18404 case RIGHT:
18405 case BOTH:
18406 case EMPTY:
18407 case MULTISET:
18408 case SUBMULTISET:
18409 case LEADING:
18410 case TRAILING:
18411 case CHAR_CS:
18412 case NCHAR_CS:
18413 case DBTIMEZONE:
18414 case SESSIONTIMEZONE:
18415 case AUTHENTICATED:
18416 case LINK:
18417 case SHARED:
18418 case DIRECTORY:
18419 case USER:
18420 case IDENTIFIER:
18421 case UNSIGNED_NUMERIC_LITERAL:
18422 case CHARACTER_LITERAL:
18423 case STRING_LITERAL:
18424 case QUOTED_LITERAL:
18425 simpleNode = UnaryExpressionNotPlusMinus();
18426 sb.append(simpleNode.getImage());
18427 break;
18428 default:
18429 jj_la1[247] = jj_gen;
18430 jj_consume_token(-1);
18431 throw new ParseException();
18432 }
18433 jjtree.closeNodeScope(jjtn000, true);
18434 jjtc000 = false;
18435 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18436 } catch (Throwable jjte000) {
18437 if (jjtc000) {
18438 jjtree.clearNodeScope(jjtn000);
18439 jjtc000 = false;
18440 } else {
18441 jjtree.popNode();
18442 }
18443 if (jjte000 instanceof RuntimeException) {
18444 {if (true) throw (RuntimeException)jjte000;}
18445 }
18446 if (jjte000 instanceof ParseException) {
18447 {if (true) throw (ParseException)jjte000;}
18448 }
18449 {if (true) throw (Error)jjte000;}
18450 } finally {
18451 if (jjtc000) {
18452 jjtree.closeNodeScope(jjtn000, true);
18453 }
18454 }
18455 throw new Error("Missing return statement in function");
18456 }
18457
18458 final public ASTUnaryExpressionNotPlusMinus UnaryExpressionNotPlusMinus() throws ParseException {
18459
18460 ASTUnaryExpressionNotPlusMinus jjtn000 = new ASTUnaryExpressionNotPlusMinus(this, JJTUNARYEXPRESSIONNOTPLUSMINUS);
18461 boolean jjtc000 = true;
18462 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18463 try {
18464 switch (jj_nt.kind) {
18465 case NOT:
18466 jj_consume_token(NOT);
18467 sb.append(" NOT ");
18468 simpleNode = UnaryExpression(false);
18469 sb.append(simpleNode.getImage());
18470 break;
18471 case 5:
18472 case REPLACE:
18473 case DEFINER:
18474 case CURRENT_USER:
18475 case LANGUAGE:
18476 case ADD:
18477 case AGGREGATE:
18478 case ARRAY:
18479 case AT:
18480 case ATTRIBUTE:
18481 case AUTHID:
18482 case BODY:
18483 case BULK:
18484 case BYTE:
18485 case CASCADE:
18486 case CASE:
18487 case CLOSE:
18488 case COALESCE:
18489 case COLLECT:
18490 case COLUMN:
18491 case COMMENT:
18492 case COMMIT:
18493 case CONSTRUCTOR:
18494 case CONTINUE:
18495 case CONVERT:
18496 case CURRENT:
18497 case CURSOR:
18498 case DATA:
18499 case DATE:
18500 case DAY:
18501 case DISABLE:
18502 case EDITIONABLE:
18503 case ELEMENT:
18504 case ENABLE:
18505 case ESCAPE:
18506 case EXCEPT:
18507 case EXCEPTIONS:
18508 case EXIT:
18509 case EXTERNAL:
18510 case EXTENDS:
18511 case EXTRACT:
18512 case FALSE:
18513 case FINAL:
18514 case FORCE:
18515 case FUNCTION:
18516 case GLOBAL:
18517 case HASH:
18518 case HEAP:
18519 case HOUR:
18520 case IMMEDIATE:
18521 case INDICES:
18522 case INDEXTYPE:
18523 case INDICATOR:
18524 case INSTANTIABLE:
18525 case INTERVAL:
18526 case INVALIDATE:
18527 case ISOLATION:
18528 case JAVA:
18529 case LEVEL:
18530 case LIMIT:
18531 case LOOP:
18532 case MAP:
18533 case MAX:
18534 case MEMBER:
18535 case MERGE:
18536 case MIN:
18537 case MINUTE:
18538 case MLSLABEL:
18539 case MODIFY:
18540 case MOD:
18541 case MONTH:
18542 case NATURAL:
18543 case NEW:
18544 case NEW_DOT:
18545 case NO:
18546 case NONEDITIONABLE:
18547 case NULL:
18548 case NULLIF:
18549 case OBJECT:
18550 case OID:
18551 case OPAQUE:
18552 case OPEN:
18553 case OPERATOR:
18554 case ORGANIZATION:
18555 case OTHERS:
18556 case OVERRIDING:
18557 case PACKAGE:
18558 case PARTITION:
18559 case PRESERVE:
18560 case PRIVATE:
18561 case PROCEDURE:
18562 case RANGE:
18563 case RAW:
18564 case REAL:
18565 case RECORD:
18566 case REF:
18567 case RELEASE:
18568 case RELIES_ON:
18569 case RENAME:
18570 case RESULT:
18571 case RETURN:
18572 case RETURNING:
18573 case REVERSE:
18574 case ROLLBACK:
18575 case ROW:
18576 case ROWS:
18577 case ROWID:
18578 case ROWNUM:
18579 case SAVE:
18580 case SAVEPOINT:
18581 case SECOND:
18582 case SELECT:
18583 case SELF:
18584 case SET:
18585 case SPACE:
18586 case SQL:
18587 case SQLCODE:
18588 case SQLERRM:
18589 case STATIC:
18590 case SUBTYPE:
18591 case SUBSTITUTABLE:
18592 case SUCCESSFUL:
18593 case SYSDATE:
18594 case SYS_REFCURSOR:
18595 case TEMPORARY:
18596 case TIME:
18597 case TIMESTAMP:
18598 case TIMEZONE_REGION:
18599 case TIMEZONE_ABBR:
18600 case TIMEZONE_MINUTE:
18601 case TIMEZONE_HOUR:
18602 case TRANSACTION:
18603 case TRUE:
18604 case TYPE:
18605 case UNDER:
18606 case USING:
18607 case YES:
18608 case SHOW:
18609 case A:
18610 case DOUBLE:
18611 case DEC:
18612 case PRECISION:
18613 case INT:
18614 case NUMERIC:
18615 case NCHAR:
18616 case NVARCHAR2:
18617 case STRING:
18618 case UROWID:
18619 case VARRAY:
18620 case VARYING:
18621 case BFILE:
18622 case BLOB:
18623 case CLOB:
18624 case NCLOB:
18625 case YEAR:
18626 case LOCAL:
18627 case WITH:
18628 case ZONE:
18629 case CHARACTER:
18630 case AFTER:
18631 case BEFORE:
18632 case OLD:
18633 case PARENT:
18634 case ANALYZE:
18635 case ASSOCIATE:
18636 case AUDIT:
18637 case COMPOUND:
18638 case DATABASE:
18639 case CALL:
18640 case DDL:
18641 case DISASSOCIATE:
18642 case EACH:
18643 case FOLLOWS:
18644 case LOGOFF:
18645 case LOGON:
18646 case NESTED:
18647 case NOAUDIT:
18648 case SCHEMA:
18649 case SERVERERROR:
18650 case SHUTDOWN:
18651 case STARTUP:
18652 case STATEMENT:
18653 case STATISTICS:
18654 case SUSPEND:
18655 case TRUNCATE:
18656 case WRAPPED:
18657 case LIBRARY:
18658 case NAME:
18659 case STRUCT:
18660 case CONTEXT:
18661 case PARAMETERS:
18662 case LENGTH:
18663 case TDO:
18664 case MAXLEN:
18665 case CHARSETID:
18666 case CHARSETFORM:
18667 case ACCEPT:
18668 case ACCESSIBLE:
18669 case COPY:
18670 case DEFINE:
18671 case DISCONNECT:
18672 case HOST:
18673 case PRINT:
18674 case QUIT:
18675 case REMARK:
18676 case UNDEFINE:
18677 case VARIABLE:
18678 case WHENEVER:
18679 case ATTACH:
18680 case CAST:
18681 case TREAT:
18682 case TRIM:
18683 case LEFT:
18684 case RIGHT:
18685 case BOTH:
18686 case EMPTY:
18687 case MULTISET:
18688 case SUBMULTISET:
18689 case LEADING:
18690 case TRAILING:
18691 case CHAR_CS:
18692 case NCHAR_CS:
18693 case DBTIMEZONE:
18694 case SESSIONTIMEZONE:
18695 case AUTHENTICATED:
18696 case LINK:
18697 case SHARED:
18698 case DIRECTORY:
18699 case USER:
18700 case IDENTIFIER:
18701 case UNSIGNED_NUMERIC_LITERAL:
18702 case CHARACTER_LITERAL:
18703 case STRING_LITERAL:
18704 case QUOTED_LITERAL:
18705 simpleNode = PrimaryExpression();
18706 sb.append(simpleNode.getImage());
18707 break;
18708 default:
18709 jj_la1[248] = jj_gen;
18710 jj_consume_token(-1);
18711 throw new ParseException();
18712 }
18713 jjtree.closeNodeScope(jjtn000, true);
18714 jjtc000 = false;
18715 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
18716 } catch (Throwable jjte000) {
18717 if (jjtc000) {
18718 jjtree.clearNodeScope(jjtn000);
18719 jjtc000 = false;
18720 } else {
18721 jjtree.popNode();
18722 }
18723 if (jjte000 instanceof RuntimeException) {
18724 {if (true) throw (RuntimeException)jjte000;}
18725 }
18726 if (jjte000 instanceof ParseException) {
18727 {if (true) throw (ParseException)jjte000;}
18728 }
18729 {if (true) throw (Error)jjte000;}
18730 } finally {
18731 if (jjtc000) {
18732 jjtree.closeNodeScope(jjtn000, true);
18733 }
18734 }
18735 throw new Error("Missing return statement in function");
18736 }
18737
18738
18739
18740
18741
18742
18743 final public ASTPrimaryExpression PrimaryExpression() throws ParseException {
18744
18745 ASTPrimaryExpression jjtn000 = new ASTPrimaryExpression(this, JJTPRIMARYEXPRESSION);
18746 boolean jjtc000 = true;
18747 jjtree.openNodeScope(jjtn000);Token thisToken ; PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
18748 try {
18749 switch (jj_nt.kind) {
18750 case NEW_DOT:
18751 jj_consume_token(NEW_DOT);
18752 simpleNode = QualifiedID();
18753 sb.append(" NEW."); sb.append(simpleNode.getImage());
18754 break;
18755 case 5:
18756 case REPLACE:
18757 case DEFINER:
18758 case CURRENT_USER:
18759 case LANGUAGE:
18760 case ADD:
18761 case AGGREGATE:
18762 case ARRAY:
18763 case AT:
18764 case ATTRIBUTE:
18765 case AUTHID:
18766 case BODY:
18767 case BULK:
18768 case BYTE:
18769 case CASCADE:
18770 case CASE:
18771 case CLOSE:
18772 case COALESCE:
18773 case COLLECT:
18774 case COLUMN:
18775 case COMMENT:
18776 case COMMIT:
18777 case CONSTRUCTOR:
18778 case CONTINUE:
18779 case CONVERT:
18780 case CURRENT:
18781 case CURSOR:
18782 case DATA:
18783 case DATE:
18784 case DAY:
18785 case DISABLE:
18786 case EDITIONABLE:
18787 case ELEMENT:
18788 case ENABLE:
18789 case ESCAPE:
18790 case EXCEPT:
18791 case EXCEPTIONS:
18792 case EXIT:
18793 case EXTERNAL:
18794 case EXTENDS:
18795 case EXTRACT:
18796 case FALSE:
18797 case FINAL:
18798 case FORCE:
18799 case FUNCTION:
18800 case GLOBAL:
18801 case HASH:
18802 case HEAP:
18803 case HOUR:
18804 case IMMEDIATE:
18805 case INDICES:
18806 case INDEXTYPE:
18807 case INDICATOR:
18808 case INSTANTIABLE:
18809 case INTERVAL:
18810 case INVALIDATE:
18811 case ISOLATION:
18812 case JAVA:
18813 case LEVEL:
18814 case LIMIT:
18815 case LOOP:
18816 case MAP:
18817 case MAX:
18818 case MEMBER:
18819 case MERGE:
18820 case MIN:
18821 case MINUTE:
18822 case MLSLABEL:
18823 case MODIFY:
18824 case MOD:
18825 case MONTH:
18826 case NATURAL:
18827 case NEW:
18828 case NO:
18829 case NONEDITIONABLE:
18830 case NULL:
18831 case NULLIF:
18832 case OBJECT:
18833 case OID:
18834 case OPAQUE:
18835 case OPEN:
18836 case OPERATOR:
18837 case ORGANIZATION:
18838 case OTHERS:
18839 case OVERRIDING:
18840 case PACKAGE:
18841 case PARTITION:
18842 case PRESERVE:
18843 case PRIVATE:
18844 case PROCEDURE:
18845 case RANGE:
18846 case RAW:
18847 case REAL:
18848 case RECORD:
18849 case REF:
18850 case RELEASE:
18851 case RELIES_ON:
18852 case RENAME:
18853 case RESULT:
18854 case RETURN:
18855 case RETURNING:
18856 case REVERSE:
18857 case ROLLBACK:
18858 case ROW:
18859 case ROWS:
18860 case ROWID:
18861 case ROWNUM:
18862 case SAVE:
18863 case SAVEPOINT:
18864 case SECOND:
18865 case SELECT:
18866 case SELF:
18867 case SET:
18868 case SPACE:
18869 case SQL:
18870 case SQLCODE:
18871 case SQLERRM:
18872 case STATIC:
18873 case SUBTYPE:
18874 case SUBSTITUTABLE:
18875 case SUCCESSFUL:
18876 case SYSDATE:
18877 case SYS_REFCURSOR:
18878 case TEMPORARY:
18879 case TIME:
18880 case TIMESTAMP:
18881 case TIMEZONE_REGION:
18882 case TIMEZONE_ABBR:
18883 case TIMEZONE_MINUTE:
18884 case TIMEZONE_HOUR:
18885 case TRANSACTION:
18886 case TRUE:
18887 case TYPE:
18888 case UNDER:
18889 case USING:
18890 case YES:
18891 case SHOW:
18892 case A:
18893 case DOUBLE:
18894 case DEC:
18895 case PRECISION:
18896 case INT:
18897 case NUMERIC:
18898 case NCHAR:
18899 case NVARCHAR2:
18900 case STRING:
18901 case UROWID:
18902 case VARRAY:
18903 case VARYING:
18904 case BFILE:
18905 case BLOB:
18906 case CLOB:
18907 case NCLOB:
18908 case YEAR:
18909 case LOCAL:
18910 case WITH:
18911 case ZONE:
18912 case CHARACTER:
18913 case AFTER:
18914 case BEFORE:
18915 case OLD:
18916 case PARENT:
18917 case ANALYZE:
18918 case ASSOCIATE:
18919 case AUDIT:
18920 case COMPOUND:
18921 case DATABASE:
18922 case CALL:
18923 case DDL:
18924 case DISASSOCIATE:
18925 case EACH:
18926 case FOLLOWS:
18927 case LOGOFF:
18928 case LOGON:
18929 case NESTED:
18930 case NOAUDIT:
18931 case SCHEMA:
18932 case SERVERERROR:
18933 case SHUTDOWN:
18934 case STARTUP:
18935 case STATEMENT:
18936 case STATISTICS:
18937 case SUSPEND:
18938 case TRUNCATE:
18939 case WRAPPED:
18940 case LIBRARY:
18941 case NAME:
18942 case STRUCT:
18943 case CONTEXT:
18944 case PARAMETERS:
18945 case LENGTH:
18946 case TDO:
18947 case MAXLEN:
18948 case CHARSETID:
18949 case CHARSETFORM:
18950 case ACCEPT:
18951 case ACCESSIBLE:
18952 case COPY:
18953 case DEFINE:
18954 case DISCONNECT:
18955 case HOST:
18956 case PRINT:
18957 case QUIT:
18958 case REMARK:
18959 case UNDEFINE:
18960 case VARIABLE:
18961 case WHENEVER:
18962 case ATTACH:
18963 case CAST:
18964 case TREAT:
18965 case TRIM:
18966 case LEFT:
18967 case RIGHT:
18968 case BOTH:
18969 case EMPTY:
18970 case MULTISET:
18971 case SUBMULTISET:
18972 case LEADING:
18973 case TRAILING:
18974 case CHAR_CS:
18975 case NCHAR_CS:
18976 case DBTIMEZONE:
18977 case SESSIONTIMEZONE:
18978 case AUTHENTICATED:
18979 case LINK:
18980 case SHARED:
18981 case DIRECTORY:
18982 case USER:
18983 case IDENTIFIER:
18984 case UNSIGNED_NUMERIC_LITERAL:
18985 case CHARACTER_LITERAL:
18986 case STRING_LITERAL:
18987 case QUOTED_LITERAL:
18988 if (jj_2_46(2147483647)) {
18989 jj_consume_token(NEW);
18990 sb.append(" NEW ");
18991 simpleNode = PrimaryPrefix();
18992 sb.append(simpleNode.getImage());
18993 } else {
18994 switch (jj_nt.kind) {
18995 case 5:
18996 case REPLACE:
18997 case DEFINER:
18998 case CURRENT_USER:
18999 case LANGUAGE:
19000 case ADD:
19001 case AGGREGATE:
19002 case ARRAY:
19003 case AT:
19004 case ATTRIBUTE:
19005 case AUTHID:
19006 case BODY:
19007 case BULK:
19008 case BYTE:
19009 case CASCADE:
19010 case CASE:
19011 case CLOSE:
19012 case COALESCE:
19013 case COLLECT:
19014 case COLUMN:
19015 case COMMENT:
19016 case COMMIT:
19017 case CONSTRUCTOR:
19018 case CONTINUE:
19019 case CONVERT:
19020 case CURRENT:
19021 case CURSOR:
19022 case DATA:
19023 case DATE:
19024 case DAY:
19025 case DISABLE:
19026 case EDITIONABLE:
19027 case ELEMENT:
19028 case ENABLE:
19029 case ESCAPE:
19030 case EXCEPT:
19031 case EXCEPTIONS:
19032 case EXIT:
19033 case EXTERNAL:
19034 case EXTENDS:
19035 case EXTRACT:
19036 case FALSE:
19037 case FINAL:
19038 case FORCE:
19039 case FUNCTION:
19040 case GLOBAL:
19041 case HASH:
19042 case HEAP:
19043 case HOUR:
19044 case IMMEDIATE:
19045 case INDICES:
19046 case INDEXTYPE:
19047 case INDICATOR:
19048 case INSTANTIABLE:
19049 case INTERVAL:
19050 case INVALIDATE:
19051 case ISOLATION:
19052 case JAVA:
19053 case LEVEL:
19054 case LIMIT:
19055 case LOOP:
19056 case MAP:
19057 case MAX:
19058 case MEMBER:
19059 case MERGE:
19060 case MIN:
19061 case MINUTE:
19062 case MLSLABEL:
19063 case MODIFY:
19064 case MOD:
19065 case MONTH:
19066 case NATURAL:
19067 case NEW:
19068 case NO:
19069 case NONEDITIONABLE:
19070 case NULL:
19071 case NULLIF:
19072 case OBJECT:
19073 case OID:
19074 case OPAQUE:
19075 case OPEN:
19076 case OPERATOR:
19077 case ORGANIZATION:
19078 case OTHERS:
19079 case OVERRIDING:
19080 case PACKAGE:
19081 case PARTITION:
19082 case PRESERVE:
19083 case PRIVATE:
19084 case PROCEDURE:
19085 case RANGE:
19086 case RAW:
19087 case REAL:
19088 case RECORD:
19089 case REF:
19090 case RELEASE:
19091 case RELIES_ON:
19092 case RENAME:
19093 case RESULT:
19094 case RETURN:
19095 case RETURNING:
19096 case REVERSE:
19097 case ROLLBACK:
19098 case ROW:
19099 case ROWS:
19100 case ROWID:
19101 case ROWNUM:
19102 case SAVE:
19103 case SAVEPOINT:
19104 case SECOND:
19105 case SELECT:
19106 case SELF:
19107 case SET:
19108 case SPACE:
19109 case SQL:
19110 case SQLCODE:
19111 case SQLERRM:
19112 case STATIC:
19113 case SUBTYPE:
19114 case SUBSTITUTABLE:
19115 case SUCCESSFUL:
19116 case SYSDATE:
19117 case SYS_REFCURSOR:
19118 case TEMPORARY:
19119 case TIME:
19120 case TIMESTAMP:
19121 case TIMEZONE_REGION:
19122 case TIMEZONE_ABBR:
19123 case TIMEZONE_MINUTE:
19124 case TIMEZONE_HOUR:
19125 case TRANSACTION:
19126 case TRUE:
19127 case TYPE:
19128 case UNDER:
19129 case USING:
19130 case YES:
19131 case SHOW:
19132 case A:
19133 case DOUBLE:
19134 case DEC:
19135 case PRECISION:
19136 case INT:
19137 case NUMERIC:
19138 case NCHAR:
19139 case NVARCHAR2:
19140 case STRING:
19141 case UROWID:
19142 case VARRAY:
19143 case VARYING:
19144 case BFILE:
19145 case BLOB:
19146 case CLOB:
19147 case NCLOB:
19148 case YEAR:
19149 case LOCAL:
19150 case WITH:
19151 case ZONE:
19152 case CHARACTER:
19153 case AFTER:
19154 case BEFORE:
19155 case OLD:
19156 case PARENT:
19157 case ANALYZE:
19158 case ASSOCIATE:
19159 case AUDIT:
19160 case COMPOUND:
19161 case DATABASE:
19162 case CALL:
19163 case DDL:
19164 case DISASSOCIATE:
19165 case EACH:
19166 case FOLLOWS:
19167 case LOGOFF:
19168 case LOGON:
19169 case NESTED:
19170 case NOAUDIT:
19171 case SCHEMA:
19172 case SERVERERROR:
19173 case SHUTDOWN:
19174 case STARTUP:
19175 case STATEMENT:
19176 case STATISTICS:
19177 case SUSPEND:
19178 case TRUNCATE:
19179 case WRAPPED:
19180 case LIBRARY:
19181 case NAME:
19182 case STRUCT:
19183 case CONTEXT:
19184 case PARAMETERS:
19185 case LENGTH:
19186 case TDO:
19187 case MAXLEN:
19188 case CHARSETID:
19189 case CHARSETFORM:
19190 case ACCEPT:
19191 case ACCESSIBLE:
19192 case COPY:
19193 case DEFINE:
19194 case DISCONNECT:
19195 case HOST:
19196 case PRINT:
19197 case QUIT:
19198 case REMARK:
19199 case UNDEFINE:
19200 case VARIABLE:
19201 case WHENEVER:
19202 case ATTACH:
19203 case CAST:
19204 case TREAT:
19205 case TRIM:
19206 case LEFT:
19207 case RIGHT:
19208 case BOTH:
19209 case EMPTY:
19210 case MULTISET:
19211 case SUBMULTISET:
19212 case LEADING:
19213 case TRAILING:
19214 case CHAR_CS:
19215 case NCHAR_CS:
19216 case DBTIMEZONE:
19217 case SESSIONTIMEZONE:
19218 case AUTHENTICATED:
19219 case LINK:
19220 case SHARED:
19221 case DIRECTORY:
19222 case USER:
19223 case IDENTIFIER:
19224 case UNSIGNED_NUMERIC_LITERAL:
19225 case CHARACTER_LITERAL:
19226 case STRING_LITERAL:
19227 case QUOTED_LITERAL:
19228 simpleNode = PrimaryPrefix();
19229 sb.append(simpleNode.getImage());
19230 break;
19231 default:
19232 jj_la1[249] = jj_gen;
19233 jj_consume_token(-1);
19234 throw new ParseException();
19235 }
19236 }
19237 label_61:
19238 while (true) {
19239 if (jj_2_47(2)) {
19240 ;
19241 } else {
19242 break label_61;
19243 }
19244 simpleNode = PrimarySuffix();
19245 sb.append(simpleNode.getImage());
19246 }
19247 break;
19248 default:
19249 jj_la1[250] = jj_gen;
19250 jj_consume_token(-1);
19251 throw new ParseException();
19252 }
19253 jjtree.closeNodeScope(jjtn000, true);
19254 jjtc000 = false;
19255 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19256 } catch (Throwable jjte000) {
19257 if (jjtc000) {
19258 jjtree.clearNodeScope(jjtn000);
19259 jjtc000 = false;
19260 } else {
19261 jjtree.popNode();
19262 }
19263 if (jjte000 instanceof RuntimeException) {
19264 {if (true) throw (RuntimeException)jjte000;}
19265 }
19266 if (jjte000 instanceof ParseException) {
19267 {if (true) throw (ParseException)jjte000;}
19268 }
19269 {if (true) throw (Error)jjte000;}
19270 } finally {
19271 if (jjtc000) {
19272 jjtree.closeNodeScope(jjtn000, true);
19273 }
19274 }
19275 throw new Error("Missing return statement in function");
19276 }
19277
19278 final public ASTPrimaryPrefix PrimaryPrefix() throws ParseException {
19279
19280 ASTPrimaryPrefix jjtn000 = new ASTPrimaryPrefix(this, JJTPRIMARYPREFIX);
19281 boolean jjtc000 = true;
19282 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null; StringBuilder sb = new StringBuilder() ;
19283 try {
19284 switch (jj_nt.kind) {
19285 case DATE:
19286 case FALSE:
19287 case INTERVAL:
19288 case NULL:
19289 case TIMESTAMP:
19290 case TRUE:
19291 case UNSIGNED_NUMERIC_LITERAL:
19292 case CHARACTER_LITERAL:
19293 case STRING_LITERAL:
19294 simpleNode = Literal();
19295 sb.append(simpleNode.getImage()) ;
19296 break;
19297 default:
19298 jj_la1[252] = jj_gen;
19299 if (jj_2_48(2147483647)) {
19300 simpleNode = MultiSetCondition();
19301 } else if (jj_2_49(2147483647)) {
19302 simpleNode = TrimExpression();
19303 } else if (jj_2_50(2147483647)) {
19304 simpleNode = CaseExpression();
19305 sb.append(simpleNode.getImage()) ;
19306 } else if (jj_2_51(2147483647)) {
19307 simpleNode = ObjectExpression();
19308 sb.append(simpleNode.getImage()) ;
19309 } else {
19310 switch (jj_nt.kind) {
19311 case REPLACE:
19312 case DEFINER:
19313 case CURRENT_USER:
19314 case LANGUAGE:
19315 case ADD:
19316 case AGGREGATE:
19317 case ARRAY:
19318 case AT:
19319 case ATTRIBUTE:
19320 case AUTHID:
19321 case BODY:
19322 case BULK:
19323 case BYTE:
19324 case CASCADE:
19325 case CLOSE:
19326 case COALESCE:
19327 case COLLECT:
19328 case COLUMN:
19329 case COMMENT:
19330 case COMMIT:
19331 case CONSTRUCTOR:
19332 case CONTINUE:
19333 case CONVERT:
19334 case CURRENT:
19335 case CURSOR:
19336 case DATA:
19337 case DAY:
19338 case DISABLE:
19339 case EDITIONABLE:
19340 case ELEMENT:
19341 case ENABLE:
19342 case ESCAPE:
19343 case EXCEPT:
19344 case EXCEPTIONS:
19345 case EXIT:
19346 case EXTERNAL:
19347 case EXTENDS:
19348 case EXTRACT:
19349 case FALSE:
19350 case FINAL:
19351 case FORCE:
19352 case FUNCTION:
19353 case GLOBAL:
19354 case HASH:
19355 case HEAP:
19356 case HOUR:
19357 case IMMEDIATE:
19358 case INDICES:
19359 case INDEXTYPE:
19360 case INDICATOR:
19361 case INSTANTIABLE:
19362 case INTERVAL:
19363 case INVALIDATE:
19364 case ISOLATION:
19365 case JAVA:
19366 case LEVEL:
19367 case LIMIT:
19368 case LOOP:
19369 case MAP:
19370 case MAX:
19371 case MEMBER:
19372 case MERGE:
19373 case MIN:
19374 case MINUTE:
19375 case MLSLABEL:
19376 case MODIFY:
19377 case MOD:
19378 case MONTH:
19379 case NATURAL:
19380 case NEW:
19381 case NO:
19382 case NONEDITIONABLE:
19383 case NULLIF:
19384 case OBJECT:
19385 case OID:
19386 case OPAQUE:
19387 case OPEN:
19388 case OPERATOR:
19389 case ORGANIZATION:
19390 case OTHERS:
19391 case OVERRIDING:
19392 case PACKAGE:
19393 case PARTITION:
19394 case PRESERVE:
19395 case PRIVATE:
19396 case PROCEDURE:
19397 case RANGE:
19398 case RAW:
19399 case REAL:
19400 case RECORD:
19401 case REF:
19402 case RELEASE:
19403 case RELIES_ON:
19404 case RENAME:
19405 case RESULT:
19406 case RETURN:
19407 case RETURNING:
19408 case REVERSE:
19409 case ROLLBACK:
19410 case ROW:
19411 case ROWS:
19412 case ROWID:
19413 case ROWNUM:
19414 case SAVE:
19415 case SAVEPOINT:
19416 case SECOND:
19417 case SELF:
19418 case SET:
19419 case SPACE:
19420 case SQL:
19421 case SQLCODE:
19422 case SQLERRM:
19423 case STATIC:
19424 case SUBTYPE:
19425 case SUBSTITUTABLE:
19426 case SUCCESSFUL:
19427 case SYSDATE:
19428 case SYS_REFCURSOR:
19429 case TEMPORARY:
19430 case TIME:
19431 case TIMESTAMP:
19432 case TIMEZONE_REGION:
19433 case TIMEZONE_ABBR:
19434 case TIMEZONE_MINUTE:
19435 case TIMEZONE_HOUR:
19436 case TRANSACTION:
19437 case TRUE:
19438 case TYPE:
19439 case UNDER:
19440 case USING:
19441 case YES:
19442 case SHOW:
19443 case A:
19444 case DOUBLE:
19445 case DEC:
19446 case PRECISION:
19447 case INT:
19448 case NUMERIC:
19449 case NCHAR:
19450 case NVARCHAR2:
19451 case STRING:
19452 case UROWID:
19453 case VARRAY:
19454 case VARYING:
19455 case BFILE:
19456 case BLOB:
19457 case CLOB:
19458 case NCLOB:
19459 case YEAR:
19460 case LOCAL:
19461 case ZONE:
19462 case CHARACTER:
19463 case AFTER:
19464 case BEFORE:
19465 case OLD:
19466 case PARENT:
19467 case ANALYZE:
19468 case ASSOCIATE:
19469 case AUDIT:
19470 case COMPOUND:
19471 case DATABASE:
19472 case CALL:
19473 case DDL:
19474 case DISASSOCIATE:
19475 case EACH:
19476 case FOLLOWS:
19477 case LOGOFF:
19478 case LOGON:
19479 case NESTED:
19480 case NOAUDIT:
19481 case SCHEMA:
19482 case SERVERERROR:
19483 case SHUTDOWN:
19484 case STARTUP:
19485 case STATEMENT:
19486 case STATISTICS:
19487 case SUSPEND:
19488 case TRUNCATE:
19489 case WRAPPED:
19490 case LIBRARY:
19491 case NAME:
19492 case STRUCT:
19493 case CONTEXT:
19494 case PARAMETERS:
19495 case LENGTH:
19496 case TDO:
19497 case MAXLEN:
19498 case CHARSETID:
19499 case CHARSETFORM:
19500 case ACCEPT:
19501 case ACCESSIBLE:
19502 case COPY:
19503 case DEFINE:
19504 case DISCONNECT:
19505 case HOST:
19506 case PRINT:
19507 case QUIT:
19508 case REMARK:
19509 case UNDEFINE:
19510 case VARIABLE:
19511 case WHENEVER:
19512 case ATTACH:
19513 case CAST:
19514 case TREAT:
19515 case TRIM:
19516 case LEFT:
19517 case RIGHT:
19518 case BOTH:
19519 case EMPTY:
19520 case MULTISET:
19521 case SUBMULTISET:
19522 case LEADING:
19523 case TRAILING:
19524 case CHAR_CS:
19525 case NCHAR_CS:
19526 case DBTIMEZONE:
19527 case SESSIONTIMEZONE:
19528 case AUTHENTICATED:
19529 case LINK:
19530 case SHARED:
19531 case DIRECTORY:
19532 case USER:
19533 case IDENTIFIER:
19534 case QUOTED_LITERAL:
19535 simpleNode = Name();
19536 sb.append(simpleNode.getImage()) ;
19537 break;
19538 default:
19539 jj_la1[253] = jj_gen;
19540 if (jj_2_52(2147483647)) {
19541 jj_consume_token(SELECT);
19542 sb.append("SELECT ...");
19543 Skip2NextTerminator(null,";");
19544 } else if (jj_2_53(2147483647)) {
19545 jj_consume_token(5);
19546 sb.append("(SELECT ...");
19547 Skip2NextTerminator("(",")");
19548 jj_consume_token(7);
19549 } else if (jj_2_54(2147483647)) {
19550 jj_consume_token(WITH);
19551 sb.append("WITH ...");
19552 Skip2NextTerminator(null,";");
19553 } else if (jj_2_55(2147483647)) {
19554 jj_consume_token(5);
19555 sb.append("(WITH ...");
19556 Skip2NextTerminator("(",")");
19557 jj_consume_token(7);
19558 } else {
19559 switch (jj_nt.kind) {
19560 case 5:
19561 jj_consume_token(5);
19562 sb.append("(");
19563 simpleNode = Expression();
19564 sb.append(simpleNode.getImage());
19565 label_62:
19566 while (true) {
19567 switch (jj_nt.kind) {
19568 case 6:
19569 ;
19570 break;
19571 default:
19572 jj_la1[251] = jj_gen;
19573 break label_62;
19574 }
19575 jj_consume_token(6);
19576 sb.append(", ");
19577 simpleNode = Expression();
19578 sb.append(simpleNode.getImage());
19579 }
19580 jj_consume_token(7);
19581 sb.append(")");
19582 break;
19583 default:
19584 jj_la1[254] = jj_gen;
19585 jj_consume_token(-1);
19586 throw new ParseException();
19587 }
19588 }
19589 }
19590 }
19591 }
19592 jjtree.closeNodeScope(jjtn000, true);
19593 jjtc000 = false;
19594 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19595 } catch (Throwable jjte000) {
19596 if (jjtc000) {
19597 jjtree.clearNodeScope(jjtn000);
19598 jjtc000 = false;
19599 } else {
19600 jjtree.popNode();
19601 }
19602 if (jjte000 instanceof RuntimeException) {
19603 {if (true) throw (RuntimeException)jjte000;}
19604 }
19605 if (jjte000 instanceof ParseException) {
19606 {if (true) throw (ParseException)jjte000;}
19607 }
19608 {if (true) throw (Error)jjte000;}
19609 } finally {
19610 if (jjtc000) {
19611 jjtree.closeNodeScope(jjtn000, true);
19612 }
19613 }
19614 throw new Error("Missing return statement in function");
19615 }
19616
19617 final public ASTPrimarySuffix PrimarySuffix() throws ParseException {
19618
19619 ASTPrimarySuffix jjtn000 = new ASTPrimarySuffix(this, JJTPRIMARYSUFFIX);
19620 boolean jjtc000 = true;
19621 jjtree.openNodeScope(jjtn000);PLSQLNode suffixNode = null ; PLSQLNode arguments = null; StringBuilder sb = new StringBuilder() ;
19622 try {
19623 switch (jj_nt.kind) {
19624 case 3:
19625 jj_consume_token(3);
19626 sb.append(".");
19627 suffixNode = QualifiedID();
19628 sb.append(suffixNode.toString()) ;
19629 break;
19630 case 2:
19631 jj_consume_token(2);
19632 sb.append("@");
19633 suffixNode = QualifiedID();
19634 sb.append(suffixNode.toString()) ;
19635 break;
19636 case AT:
19637 jj_consume_token(AT);
19638 sb.append(" "); sb.append(token.image.toUpperCase());
19639 switch (jj_nt.kind) {
19640 case LOCAL:
19641 jj_consume_token(LOCAL);
19642 sb.append(" "); sb.append(token.image.toUpperCase());
19643 break;
19644 case TIME:
19645 jj_consume_token(TIME);
19646 jj_consume_token(ZONE);
19647 sb.append(" TIME ZONE");
19648 switch (jj_nt.kind) {
19649 case DBTIMEZONE:
19650 jj_consume_token(DBTIMEZONE);
19651 sb.append(" "); sb.append(token.image.toUpperCase());
19652 break;
19653 case SESSIONTIMEZONE:
19654 jj_consume_token(SESSIONTIMEZONE);
19655 sb.append(" "); sb.append(token.image.toUpperCase());
19656 break;
19657 case STRING_LITERAL:
19658 suffixNode = StringLiteral();
19659 sb.append(" "); sb.append(suffixNode.toString());
19660 break;
19661 case 5:
19662 case 16:
19663 case 17:
19664 case REPLACE:
19665 case DEFINER:
19666 case CURRENT_USER:
19667 case LANGUAGE:
19668 case ADD:
19669 case AGGREGATE:
19670 case ARRAY:
19671 case AT:
19672 case ATTRIBUTE:
19673 case AUTHID:
19674 case BODY:
19675 case BULK:
19676 case BYTE:
19677 case CASCADE:
19678 case CASE:
19679 case CLOSE:
19680 case COALESCE:
19681 case COLLECT:
19682 case COLUMN:
19683 case COMMENT:
19684 case COMMIT:
19685 case CONSTRUCTOR:
19686 case CONTINUE:
19687 case CONVERT:
19688 case CURRENT:
19689 case CURSOR:
19690 case DATA:
19691 case DATE:
19692 case DAY:
19693 case DISABLE:
19694 case EDITIONABLE:
19695 case ELEMENT:
19696 case ENABLE:
19697 case ESCAPE:
19698 case EXCEPT:
19699 case EXCEPTIONS:
19700 case EXIT:
19701 case EXTERNAL:
19702 case EXTENDS:
19703 case EXTRACT:
19704 case FALSE:
19705 case FINAL:
19706 case FORCE:
19707 case FUNCTION:
19708 case GLOBAL:
19709 case HASH:
19710 case HEAP:
19711 case HOUR:
19712 case IMMEDIATE:
19713 case INDICES:
19714 case INDEXTYPE:
19715 case INDICATOR:
19716 case INSTANTIABLE:
19717 case INTERVAL:
19718 case INVALIDATE:
19719 case ISOLATION:
19720 case JAVA:
19721 case LEVEL:
19722 case LIMIT:
19723 case LOOP:
19724 case MAP:
19725 case MAX:
19726 case MEMBER:
19727 case MERGE:
19728 case MIN:
19729 case MINUTE:
19730 case MLSLABEL:
19731 case MODIFY:
19732 case MOD:
19733 case MONTH:
19734 case NATURAL:
19735 case NEW:
19736 case NEW_DOT:
19737 case NO:
19738 case NONEDITIONABLE:
19739 case NOT:
19740 case NULL:
19741 case NULLIF:
19742 case OBJECT:
19743 case OID:
19744 case OPAQUE:
19745 case OPEN:
19746 case OPERATOR:
19747 case ORGANIZATION:
19748 case OTHERS:
19749 case OVERRIDING:
19750 case PACKAGE:
19751 case PARTITION:
19752 case PRESERVE:
19753 case PRIVATE:
19754 case PROCEDURE:
19755 case RANGE:
19756 case RAW:
19757 case REAL:
19758 case RECORD:
19759 case REF:
19760 case RELEASE:
19761 case RELIES_ON:
19762 case RENAME:
19763 case RESULT:
19764 case RETURN:
19765 case RETURNING:
19766 case REVERSE:
19767 case ROLLBACK:
19768 case ROW:
19769 case ROWS:
19770 case ROWID:
19771 case ROWNUM:
19772 case SAVE:
19773 case SAVEPOINT:
19774 case SECOND:
19775 case SELECT:
19776 case SELF:
19777 case SET:
19778 case SPACE:
19779 case SQL:
19780 case SQLCODE:
19781 case SQLERRM:
19782 case STATIC:
19783 case SUBTYPE:
19784 case SUBSTITUTABLE:
19785 case SUCCESSFUL:
19786 case SYSDATE:
19787 case SYS_REFCURSOR:
19788 case TEMPORARY:
19789 case TIME:
19790 case TIMESTAMP:
19791 case TIMEZONE_REGION:
19792 case TIMEZONE_ABBR:
19793 case TIMEZONE_MINUTE:
19794 case TIMEZONE_HOUR:
19795 case TRANSACTION:
19796 case TRUE:
19797 case TYPE:
19798 case UNDER:
19799 case USING:
19800 case YES:
19801 case SHOW:
19802 case A:
19803 case DOUBLE:
19804 case DEC:
19805 case PRECISION:
19806 case INT:
19807 case NUMERIC:
19808 case NCHAR:
19809 case NVARCHAR2:
19810 case STRING:
19811 case UROWID:
19812 case VARRAY:
19813 case VARYING:
19814 case BFILE:
19815 case BLOB:
19816 case CLOB:
19817 case NCLOB:
19818 case YEAR:
19819 case LOCAL:
19820 case WITH:
19821 case ZONE:
19822 case CHARACTER:
19823 case AFTER:
19824 case BEFORE:
19825 case OLD:
19826 case PARENT:
19827 case CC_IF:
19828 case ANALYZE:
19829 case ASSOCIATE:
19830 case AUDIT:
19831 case COMPOUND:
19832 case DATABASE:
19833 case CALL:
19834 case DDL:
19835 case DISASSOCIATE:
19836 case EACH:
19837 case FOLLOWS:
19838 case LOGOFF:
19839 case LOGON:
19840 case NESTED:
19841 case NOAUDIT:
19842 case SCHEMA:
19843 case SERVERERROR:
19844 case SHUTDOWN:
19845 case STARTUP:
19846 case STATEMENT:
19847 case STATISTICS:
19848 case SUSPEND:
19849 case TRUNCATE:
19850 case WRAPPED:
19851 case LIBRARY:
19852 case NAME:
19853 case STRUCT:
19854 case CONTEXT:
19855 case PARAMETERS:
19856 case LENGTH:
19857 case TDO:
19858 case MAXLEN:
19859 case CHARSETID:
19860 case CHARSETFORM:
19861 case ACCEPT:
19862 case ACCESSIBLE:
19863 case COPY:
19864 case DEFINE:
19865 case DISCONNECT:
19866 case HOST:
19867 case PRINT:
19868 case QUIT:
19869 case REMARK:
19870 case UNDEFINE:
19871 case VARIABLE:
19872 case WHENEVER:
19873 case ATTACH:
19874 case CAST:
19875 case TREAT:
19876 case TRIM:
19877 case LEFT:
19878 case RIGHT:
19879 case BOTH:
19880 case EMPTY:
19881 case MULTISET:
19882 case SUBMULTISET:
19883 case LEADING:
19884 case TRAILING:
19885 case CHAR_CS:
19886 case NCHAR_CS:
19887 case AUTHENTICATED:
19888 case LINK:
19889 case SHARED:
19890 case DIRECTORY:
19891 case USER:
19892 case IDENTIFIER:
19893 case UNSIGNED_NUMERIC_LITERAL:
19894 case CHARACTER_LITERAL:
19895 case QUOTED_LITERAL:
19896 suffixNode = Expression();
19897 sb.append(" "); sb.append(suffixNode.toString());
19898 break;
19899 default:
19900 jj_la1[255] = jj_gen;
19901 jj_consume_token(-1);
19902 throw new ParseException();
19903 }
19904 break;
19905 default:
19906 jj_la1[256] = jj_gen;
19907 jj_consume_token(-1);
19908 throw new ParseException();
19909 }
19910 break;
19911 case 5:
19912 arguments = Arguments();
19913 sb.append(arguments) ;
19914 break;
19915 default:
19916 jj_la1[257] = jj_gen;
19917 jj_consume_token(-1);
19918 throw new ParseException();
19919 }
19920 jjtree.closeNodeScope(jjtn000, true);
19921 jjtc000 = false;
19922 jjtn000.setImage(sb.toString()); {if (true) return jjtn000;}
19923 } catch (Throwable jjte000) {
19924 if (jjtc000) {
19925 jjtree.clearNodeScope(jjtn000);
19926 jjtc000 = false;
19927 } else {
19928 jjtree.popNode();
19929 }
19930 if (jjte000 instanceof RuntimeException) {
19931 {if (true) throw (RuntimeException)jjte000;}
19932 }
19933 if (jjte000 instanceof ParseException) {
19934 {if (true) throw (ParseException)jjte000;}
19935 }
19936 {if (true) throw (Error)jjte000;}
19937 } finally {
19938 if (jjtc000) {
19939 jjtree.closeNodeScope(jjtn000, true);
19940 }
19941 }
19942 throw new Error("Missing return statement in function");
19943 }
19944
19945 final public ASTLiteral Literal() throws ParseException {
19946
19947 ASTLiteral jjtn000 = new ASTLiteral(this, JJTLITERAL);
19948 boolean jjtc000 = true;
19949 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
19950 Token t = null ;
19951 try {
19952 switch (jj_nt.kind) {
19953 case UNSIGNED_NUMERIC_LITERAL:
19954 simpleNode = NumericLiteral();
19955 break;
19956 case CHARACTER_LITERAL:
19957 t = jj_consume_token(CHARACTER_LITERAL);
19958 break;
19959 case STRING_LITERAL:
19960
19961 simpleNode = StringLiteral();
19962 break;
19963 case FALSE:
19964 case TRUE:
19965 simpleNode = BooleanLiteral();
19966 break;
19967 case NULL:
19968 simpleNode = NullLiteral();
19969 break;
19970 case DATE:
19971 case INTERVAL:
19972 case TIMESTAMP:
19973 simpleNode = DateTimeLiteral();
19974 break;
19975 default:
19976 jj_la1[258] = jj_gen;
19977 jj_consume_token(-1);
19978 throw new ParseException();
19979 }
19980 jjtree.closeNodeScope(jjtn000, true);
19981 jjtc000 = false;
19982 if (null != simpleNode)
19983 {
19984 jjtn000.setImage( simpleNode.getImage() ) ;
19985 }
19986 else if (null != t)
19987 {
19988 jjtn000.setImage( t.image ) ;
19989 }
19990 {if (true) return jjtn000 ;}
19991 } catch (Throwable jjte000) {
19992 if (jjtc000) {
19993 jjtree.clearNodeScope(jjtn000);
19994 jjtc000 = false;
19995 } else {
19996 jjtree.popNode();
19997 }
19998 if (jjte000 instanceof RuntimeException) {
19999 {if (true) throw (RuntimeException)jjte000;}
20000 }
20001 if (jjte000 instanceof ParseException) {
20002 {if (true) throw (ParseException)jjte000;}
20003 }
20004 {if (true) throw (Error)jjte000;}
20005 } finally {
20006 if (jjtc000) {
20007 jjtree.closeNodeScope(jjtn000, true);
20008 }
20009 }
20010 throw new Error("Missing return statement in function");
20011 }
20012
20013 final public ASTStringLiteral StringLiteral() throws ParseException {
20014
20015 ASTStringLiteral jjtn000 = new ASTStringLiteral(this, JJTSTRINGLITERAL);
20016 boolean jjtc000 = true;
20017 jjtree.openNodeScope(jjtn000);Token thisToken = null;
20018 StringBuilder literal = new StringBuilder() ;
20019 char startDelimiter ;
20020 char endDelimiter ;
20021 String terminator = null;
20022 try {
20023 thisToken = jj_consume_token(STRING_LITERAL);
20024 literal.append(thisToken.image);
20025
20026
20027
20028
20029
20030 if (thisToken.image.toUpperCase().startsWith("Q'")
20031 && thisToken.image.length() > 2
20032 )
20033 {
20034
20035
20036 startDelimiter= thisToken.image.charAt(2) ;
20037
20038
20039
20040
20041 switch (startDelimiter)
20042 {
20043 case '<' : endDelimiter = '>' ; break ;
20044 case '{' : endDelimiter = '}' ; break ;
20045 case '(' : endDelimiter = ')' ; break ;
20046 case '[' : endDelimiter = ']' ; break ;
20047 default: endDelimiter = startDelimiter ;
20048 }
20049
20050 terminator = new String(endDelimiter + "'");
20051 if (!thisToken.image.endsWith(terminator))
20052 {
20053
20054 literal.append(ReadPastNextOccurrence(terminator));
20055 }
20056 }
20057 jjtree.closeNodeScope(jjtn000, true);
20058 jjtc000 = false;
20059 jjtn000.setImage(literal.toString()) ; jjtn000.value = literal.toString() ; {if (true) return jjtn000 ;}
20060 } finally {
20061 if (jjtc000) {
20062 jjtree.closeNodeScope(jjtn000, true);
20063 }
20064 }
20065 throw new Error("Missing return statement in function");
20066 }
20067
20068 final public ASTBooleanLiteral BooleanLiteral() throws ParseException {
20069
20070 ASTBooleanLiteral jjtn000 = new ASTBooleanLiteral(this, JJTBOOLEANLITERAL);
20071 boolean jjtc000 = true;
20072 jjtree.openNodeScope(jjtn000);
20073 try {
20074 switch (jj_nt.kind) {
20075 case TRUE:
20076 jj_consume_token(TRUE);
20077 break;
20078 case FALSE:
20079 jj_consume_token(FALSE);
20080 break;
20081 default:
20082 jj_la1[259] = jj_gen;
20083 jj_consume_token(-1);
20084 throw new ParseException();
20085 }
20086 jjtree.closeNodeScope(jjtn000, true);
20087 jjtc000 = false;
20088 jjtn000.setImage(token.image) ;
20089 {if (true) return jjtn000;}
20090 } finally {
20091 if (jjtc000) {
20092 jjtree.closeNodeScope(jjtn000, true);
20093 }
20094 }
20095 throw new Error("Missing return statement in function");
20096 }
20097
20098 final public ASTNullLiteral NullLiteral() throws ParseException {
20099
20100 ASTNullLiteral jjtn000 = new ASTNullLiteral(this, JJTNULLLITERAL);
20101 boolean jjtc000 = true;
20102 jjtree.openNodeScope(jjtn000);
20103 try {
20104 jj_consume_token(NULL);
20105 jjtree.closeNodeScope(jjtn000, true);
20106 jjtc000 = false;
20107 jjtn000.setImage(token.image) ;
20108 {if (true) return jjtn000 ;}
20109 } finally {
20110 if (jjtc000) {
20111 jjtree.closeNodeScope(jjtn000, true);
20112 }
20113 }
20114 throw new Error("Missing return statement in function");
20115 }
20116
20117 final public ASTMultiSetCondition MultiSetCondition() throws ParseException {
20118
20119 ASTMultiSetCondition jjtn000 = new ASTMultiSetCondition(this, JJTMULTISETCONDITION);
20120 boolean jjtc000 = true;
20121 jjtree.openNodeScope(jjtn000);
20122 try {
20123 switch (jj_nt.kind) {
20124 case A:
20125 jj_consume_token(A);
20126 jj_consume_token(SET);
20127 break;
20128 case EMPTY:
20129 jj_consume_token(EMPTY);
20130 break;
20131 default:
20132 jj_la1[260] = jj_gen;
20133 jj_consume_token(-1);
20134 throw new ParseException();
20135 }
20136 jjtree.closeNodeScope(jjtn000, true);
20137 jjtc000 = false;
20138 {if (true) return jjtn000;}
20139 } finally {
20140 if (jjtc000) {
20141 jjtree.closeNodeScope(jjtn000, true);
20142 }
20143 }
20144 throw new Error("Missing return statement in function");
20145 }
20146
20147
20148
20149
20150
20151
20152 final public ASTNumericLiteral NumericLiteral() throws ParseException {
20153
20154 ASTNumericLiteral jjtn000 = new ASTNumericLiteral(this, JJTNUMERICLITERAL);
20155 boolean jjtc000 = true;
20156 jjtree.openNodeScope(jjtn000);Token t = null ;
20157 try {
20158
20159 t = jj_consume_token(UNSIGNED_NUMERIC_LITERAL);
20160 jjtree.closeNodeScope(jjtn000, true);
20161 jjtc000 = false;
20162 jjtn000.setImage(t.image) ;
20163 {if (true) return jjtn000;}
20164 } finally {
20165 if (jjtc000) {
20166 jjtree.closeNodeScope(jjtn000, true);
20167 }
20168 }
20169 throw new Error("Missing return statement in function");
20170 }
20171
20172
20173
20174 final public ASTLabel Label() throws ParseException {
20175
20176 ASTLabel jjtn000 = new ASTLabel(this, JJTLABEL);
20177 boolean jjtc000 = true;
20178 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20179 try {
20180 jj_consume_token(21);
20181 simpleNode = UnqualifiedID();
20182 jj_consume_token(22);
20183 jjtree.closeNodeScope(jjtn000, true);
20184 jjtc000 = false;
20185 jjtn000.setImage( simpleNode.getImage() ) ;
20186 {if (true) return jjtn000;}
20187 } catch (Throwable jjte000) {
20188 if (jjtc000) {
20189 jjtree.clearNodeScope(jjtn000);
20190 jjtc000 = false;
20191 } else {
20192 jjtree.popNode();
20193 }
20194 if (jjte000 instanceof RuntimeException) {
20195 {if (true) throw (RuntimeException)jjte000;}
20196 }
20197 if (jjte000 instanceof ParseException) {
20198 {if (true) throw (ParseException)jjte000;}
20199 }
20200 {if (true) throw (Error)jjte000;}
20201 } finally {
20202 if (jjtc000) {
20203 jjtree.closeNodeScope(jjtn000, true);
20204 }
20205 }
20206 throw new Error("Missing return statement in function");
20207 }
20208
20209 final public ASTName Name() throws ParseException {
20210
20211 ASTName jjtn000 = new ASTName(this, JJTNAME);
20212 boolean jjtc000 = true;
20213 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20214 StringBuilder sb = new StringBuilder();
20215 try {
20216 simpleNode = UnqualifiedID();
20217 sb.append(simpleNode.getImage()) ;
20218 label_63:
20219 while (true) {
20220 if (jj_2_56(2)) {
20221 ;
20222 } else {
20223 break label_63;
20224 }
20225 switch (jj_nt.kind) {
20226 case 3:
20227 jj_consume_token(3);
20228 sb.append(".") ;
20229 break;
20230 case 11:
20231 jj_consume_token(11);
20232 sb.append("%") ;
20233 break;
20234 default:
20235 jj_la1[261] = jj_gen;
20236 jj_consume_token(-1);
20237 throw new ParseException();
20238 }
20239
20240 simpleNode = QualifiedID();
20241 sb.append(simpleNode.getImage()) ;
20242 }
20243 jjtree.closeNodeScope(jjtn000, true);
20244 jjtc000 = false;
20245 jjtn000.setImage(sb.toString()) ;
20246 {if (true) return jjtn000;}
20247 } catch (Throwable jjte000) {
20248 if (jjtc000) {
20249 jjtree.clearNodeScope(jjtn000);
20250 jjtc000 = false;
20251 } else {
20252 jjtree.popNode();
20253 }
20254 if (jjte000 instanceof RuntimeException) {
20255 {if (true) throw (RuntimeException)jjte000;}
20256 }
20257 if (jjte000 instanceof ParseException) {
20258 {if (true) throw (ParseException)jjte000;}
20259 }
20260 {if (true) throw (Error)jjte000;}
20261 } finally {
20262 if (jjtc000) {
20263 jjtree.closeNodeScope(jjtn000, true);
20264 }
20265 }
20266 throw new Error("Missing return statement in function");
20267 }
20268
20269 final public ASTQualifiedName QualifiedName() throws ParseException {
20270
20271 ASTQualifiedName jjtn000 = new ASTQualifiedName(this, JJTQUALIFIEDNAME);
20272 boolean jjtc000 = true;
20273 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20274 StringBuilder sb = new StringBuilder();
20275 try {
20276 simpleNode = UnqualifiedID();
20277 sb.append(simpleNode.getImage()) ;
20278 label_64:
20279 while (true) {
20280 switch (jj_nt.kind) {
20281 case 3:
20282 ;
20283 break;
20284 default:
20285 jj_la1[262] = jj_gen;
20286 break label_64;
20287 }
20288 jj_consume_token(3);
20289 simpleNode = QualifiedID();
20290 sb.append(".") ; sb.append(simpleNode.getImage()) ;
20291 }
20292 jjtree.closeNodeScope(jjtn000, true);
20293 jjtc000 = false;
20294 jjtn000.setImage(sb.toString()) ;
20295 {if (true) return jjtn000 ;}
20296 } catch (Throwable jjte000) {
20297 if (jjtc000) {
20298 jjtree.clearNodeScope(jjtn000);
20299 jjtc000 = false;
20300 } else {
20301 jjtree.popNode();
20302 }
20303 if (jjte000 instanceof RuntimeException) {
20304 {if (true) throw (RuntimeException)jjte000;}
20305 }
20306 if (jjte000 instanceof ParseException) {
20307 {if (true) throw (ParseException)jjte000;}
20308 }
20309 {if (true) throw (Error)jjte000;}
20310 } finally {
20311 if (jjtc000) {
20312 jjtree.closeNodeScope(jjtn000, true);
20313 }
20314 }
20315 throw new Error("Missing return statement in function");
20316 }
20317
20318 final public ASTArguments Arguments() throws ParseException {
20319
20320 ASTArguments jjtn000 = new ASTArguments(this, JJTARGUMENTS);
20321 boolean jjtc000 = true;
20322 jjtree.openNodeScope(jjtn000);
20323 try {
20324 jj_consume_token(5);
20325 switch (jj_nt.kind) {
20326 case 5:
20327 case 16:
20328 case 17:
20329 case REPLACE:
20330 case DEFINER:
20331 case CURRENT_USER:
20332 case LANGUAGE:
20333 case ADD:
20334 case AGGREGATE:
20335 case ARRAY:
20336 case AT:
20337 case ATTRIBUTE:
20338 case AUTHID:
20339 case BODY:
20340 case BULK:
20341 case BYTE:
20342 case CASCADE:
20343 case CASE:
20344 case CLOSE:
20345 case COALESCE:
20346 case COLLECT:
20347 case COLUMN:
20348 case COMMENT:
20349 case COMMIT:
20350 case CONSTRUCTOR:
20351 case CONTINUE:
20352 case CONVERT:
20353 case CURRENT:
20354 case CURSOR:
20355 case DATA:
20356 case DATE:
20357 case DAY:
20358 case DISABLE:
20359 case EDITIONABLE:
20360 case ELEMENT:
20361 case ENABLE:
20362 case ESCAPE:
20363 case EXCEPT:
20364 case EXCEPTIONS:
20365 case EXIT:
20366 case EXTERNAL:
20367 case EXTENDS:
20368 case EXTRACT:
20369 case FALSE:
20370 case FINAL:
20371 case FORCE:
20372 case FUNCTION:
20373 case GLOBAL:
20374 case HASH:
20375 case HEAP:
20376 case HOUR:
20377 case IMMEDIATE:
20378 case INDICES:
20379 case INDEXTYPE:
20380 case INDICATOR:
20381 case INSTANTIABLE:
20382 case INTERVAL:
20383 case INVALIDATE:
20384 case ISOLATION:
20385 case JAVA:
20386 case LEVEL:
20387 case LIMIT:
20388 case LOOP:
20389 case MAP:
20390 case MAX:
20391 case MEMBER:
20392 case MERGE:
20393 case MIN:
20394 case MINUTE:
20395 case MLSLABEL:
20396 case MODIFY:
20397 case MOD:
20398 case MONTH:
20399 case NATURAL:
20400 case NEW:
20401 case NEW_DOT:
20402 case NO:
20403 case NONEDITIONABLE:
20404 case NOT:
20405 case NULL:
20406 case NULLIF:
20407 case OBJECT:
20408 case OID:
20409 case OPAQUE:
20410 case OPEN:
20411 case OPERATOR:
20412 case ORGANIZATION:
20413 case OTHERS:
20414 case OVERRIDING:
20415 case PACKAGE:
20416 case PARTITION:
20417 case PRESERVE:
20418 case PRIVATE:
20419 case PROCEDURE:
20420 case RANGE:
20421 case RAW:
20422 case REAL:
20423 case RECORD:
20424 case REF:
20425 case RELEASE:
20426 case RELIES_ON:
20427 case RENAME:
20428 case RESULT:
20429 case RETURN:
20430 case RETURNING:
20431 case REVERSE:
20432 case ROLLBACK:
20433 case ROW:
20434 case ROWS:
20435 case ROWID:
20436 case ROWNUM:
20437 case SAVE:
20438 case SAVEPOINT:
20439 case SECOND:
20440 case SELECT:
20441 case SELF:
20442 case SET:
20443 case SPACE:
20444 case SQL:
20445 case SQLCODE:
20446 case SQLERRM:
20447 case STATIC:
20448 case SUBTYPE:
20449 case SUBSTITUTABLE:
20450 case SUCCESSFUL:
20451 case SYSDATE:
20452 case SYS_REFCURSOR:
20453 case TEMPORARY:
20454 case TIME:
20455 case TIMESTAMP:
20456 case TIMEZONE_REGION:
20457 case TIMEZONE_ABBR:
20458 case TIMEZONE_MINUTE:
20459 case TIMEZONE_HOUR:
20460 case TRANSACTION:
20461 case TRUE:
20462 case TYPE:
20463 case UNDER:
20464 case USING:
20465 case YES:
20466 case SHOW:
20467 case A:
20468 case DOUBLE:
20469 case DEC:
20470 case PRECISION:
20471 case INT:
20472 case NUMERIC:
20473 case NCHAR:
20474 case NVARCHAR2:
20475 case STRING:
20476 case UROWID:
20477 case VARRAY:
20478 case VARYING:
20479 case BFILE:
20480 case BLOB:
20481 case CLOB:
20482 case NCLOB:
20483 case YEAR:
20484 case LOCAL:
20485 case WITH:
20486 case ZONE:
20487 case CHARACTER:
20488 case AFTER:
20489 case BEFORE:
20490 case OLD:
20491 case PARENT:
20492 case CC_IF:
20493 case ANALYZE:
20494 case ASSOCIATE:
20495 case AUDIT:
20496 case COMPOUND:
20497 case DATABASE:
20498 case CALL:
20499 case DDL:
20500 case DISASSOCIATE:
20501 case EACH:
20502 case FOLLOWS:
20503 case LOGOFF:
20504 case LOGON:
20505 case NESTED:
20506 case NOAUDIT:
20507 case SCHEMA:
20508 case SERVERERROR:
20509 case SHUTDOWN:
20510 case STARTUP:
20511 case STATEMENT:
20512 case STATISTICS:
20513 case SUSPEND:
20514 case TRUNCATE:
20515 case WRAPPED:
20516 case LIBRARY:
20517 case NAME:
20518 case STRUCT:
20519 case CONTEXT:
20520 case PARAMETERS:
20521 case LENGTH:
20522 case TDO:
20523 case MAXLEN:
20524 case CHARSETID:
20525 case CHARSETFORM:
20526 case ACCEPT:
20527 case ACCESSIBLE:
20528 case COPY:
20529 case DEFINE:
20530 case DISCONNECT:
20531 case HOST:
20532 case PRINT:
20533 case QUIT:
20534 case REMARK:
20535 case UNDEFINE:
20536 case VARIABLE:
20537 case WHENEVER:
20538 case ATTACH:
20539 case CAST:
20540 case TREAT:
20541 case TRIM:
20542 case LEFT:
20543 case RIGHT:
20544 case BOTH:
20545 case EMPTY:
20546 case MULTISET:
20547 case SUBMULTISET:
20548 case LEADING:
20549 case TRAILING:
20550 case CHAR_CS:
20551 case NCHAR_CS:
20552 case DBTIMEZONE:
20553 case SESSIONTIMEZONE:
20554 case AUTHENTICATED:
20555 case LINK:
20556 case SHARED:
20557 case DIRECTORY:
20558 case USER:
20559 case IDENTIFIER:
20560 case UNSIGNED_NUMERIC_LITERAL:
20561 case CHARACTER_LITERAL:
20562 case STRING_LITERAL:
20563 case QUOTED_LITERAL:
20564 ArgumentList();
20565 break;
20566 default:
20567 jj_la1[263] = jj_gen;
20568 ;
20569 }
20570 jj_consume_token(7);
20571 jjtree.closeNodeScope(jjtn000, true);
20572 jjtc000 = false;
20573 {if (true) return jjtn000 ;}
20574 } catch (Throwable jjte000) {
20575 if (jjtc000) {
20576 jjtree.clearNodeScope(jjtn000);
20577 jjtc000 = false;
20578 } else {
20579 jjtree.popNode();
20580 }
20581 if (jjte000 instanceof RuntimeException) {
20582 {if (true) throw (RuntimeException)jjte000;}
20583 }
20584 if (jjte000 instanceof ParseException) {
20585 {if (true) throw (ParseException)jjte000;}
20586 }
20587 {if (true) throw (Error)jjte000;}
20588 } finally {
20589 if (jjtc000) {
20590 jjtree.closeNodeScope(jjtn000, true);
20591 }
20592 }
20593 throw new Error("Missing return statement in function");
20594 }
20595
20596 final public ASTArgumentList ArgumentList() throws ParseException {
20597
20598 ASTArgumentList jjtn000 = new ASTArgumentList(this, JJTARGUMENTLIST);
20599 boolean jjtc000 = true;
20600 jjtree.openNodeScope(jjtn000);
20601 try {
20602 Argument();
20603 label_65:
20604 while (true) {
20605 switch (jj_nt.kind) {
20606 case 6:
20607 ;
20608 break;
20609 default:
20610 jj_la1[264] = jj_gen;
20611 break label_65;
20612 }
20613 jj_consume_token(6);
20614 Argument();
20615 }
20616 jjtree.closeNodeScope(jjtn000, true);
20617 jjtc000 = false;
20618 {if (true) return jjtn000 ;}
20619 } catch (Throwable jjte000) {
20620 if (jjtc000) {
20621 jjtree.clearNodeScope(jjtn000);
20622 jjtc000 = false;
20623 } else {
20624 jjtree.popNode();
20625 }
20626 if (jjte000 instanceof RuntimeException) {
20627 {if (true) throw (RuntimeException)jjte000;}
20628 }
20629 if (jjte000 instanceof ParseException) {
20630 {if (true) throw (ParseException)jjte000;}
20631 }
20632 {if (true) throw (Error)jjte000;}
20633 } finally {
20634 if (jjtc000) {
20635 jjtree.closeNodeScope(jjtn000, true);
20636 }
20637 }
20638 throw new Error("Missing return statement in function");
20639 }
20640
20641 final public ASTArgument Argument() throws ParseException {
20642
20643 ASTArgument jjtn000 = new ASTArgument(this, JJTARGUMENT);
20644 boolean jjtc000 = true;
20645 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
20646 try {
20647 if (jj_2_57(2)) {
20648 simpleNode = UnqualifiedID();
20649 switch (jj_nt.kind) {
20650 case 23:
20651 jj_consume_token(23);
20652 break;
20653 case AS:
20654 jj_consume_token(AS);
20655 break;
20656 default:
20657 jj_la1[265] = jj_gen;
20658 jj_consume_token(-1);
20659 throw new ParseException();
20660 }
20661 } else {
20662 ;
20663 }
20664 Expression();
20665 switch (jj_nt.kind) {
20666 case USING:
20667 jj_consume_token(USING);
20668 switch (jj_nt.kind) {
20669 case CHAR_CS:
20670 jj_consume_token(CHAR_CS);
20671 break;
20672 case NCHAR_CS:
20673 jj_consume_token(NCHAR_CS);
20674 break;
20675 default:
20676 jj_la1[266] = jj_gen;
20677 jj_consume_token(-1);
20678 throw new ParseException();
20679 }
20680 break;
20681 default:
20682 jj_la1[267] = jj_gen;
20683 ;
20684 }
20685 jjtree.closeNodeScope(jjtn000, true);
20686 jjtc000 = false;
20687 if (null != simpleNode) { jjtn000.setImage(simpleNode.getImage()) ; }
20688 {if (true) return jjtn000 ;}
20689 } catch (Throwable jjte000) {
20690 if (jjtc000) {
20691 jjtree.clearNodeScope(jjtn000);
20692 jjtc000 = false;
20693 } else {
20694 jjtree.popNode();
20695 }
20696 if (jjte000 instanceof RuntimeException) {
20697 {if (true) throw (RuntimeException)jjte000;}
20698 }
20699 if (jjte000 instanceof ParseException) {
20700 {if (true) throw (ParseException)jjte000;}
20701 }
20702 {if (true) throw (Error)jjte000;}
20703 } finally {
20704 if (jjtc000) {
20705 jjtree.closeNodeScope(jjtn000, true);
20706 }
20707 }
20708 throw new Error("Missing return statement in function");
20709 }
20710
20711
20712
20713
20714 final public ASTVariableOrConstantDeclaration VariableOrConstantDeclaration() throws ParseException {
20715
20716 ASTVariableOrConstantDeclaration jjtn000 = new ASTVariableOrConstantDeclaration(this, JJTVARIABLEORCONSTANTDECLARATION);
20717 boolean jjtc000 = true;
20718 jjtree.openNodeScope(jjtn000);
20719 try {
20720 VariableOrConstantDeclarator();
20721 jj_consume_token(4);
20722 jjtree.closeNodeScope(jjtn000, true);
20723 jjtc000 = false;
20724 {if (true) return jjtn000 ;}
20725 } catch (Throwable jjte000) {
20726 if (jjtc000) {
20727 jjtree.clearNodeScope(jjtn000);
20728 jjtc000 = false;
20729 } else {
20730 jjtree.popNode();
20731 }
20732 if (jjte000 instanceof RuntimeException) {
20733 {if (true) throw (RuntimeException)jjte000;}
20734 }
20735 if (jjte000 instanceof ParseException) {
20736 {if (true) throw (ParseException)jjte000;}
20737 }
20738 {if (true) throw (Error)jjte000;}
20739 } finally {
20740 if (jjtc000) {
20741 jjtree.closeNodeScope(jjtn000, true);
20742 }
20743 }
20744 throw new Error("Missing return statement in function");
20745 }
20746
20747 final public ASTDatatypeDeclaration DatatypeDeclaration() throws ParseException {
20748
20749 ASTDatatypeDeclaration jjtn000 = new ASTDatatypeDeclaration(this, JJTDATATYPEDECLARATION);
20750 boolean jjtc000 = true;
20751 jjtree.openNodeScope(jjtn000);Token t ;
20752 try {
20753 t = jj_consume_token(IDENTIFIER);
20754 jjtree.closeNodeScope(jjtn000, true);
20755 jjtc000 = false;
20756 jjtn000.setImage(t.image) ; {if (true) return jjtn000 ;}
20757 } finally {
20758 if (jjtc000) {
20759 jjtree.closeNodeScope(jjtn000, true);
20760 }
20761 }
20762 throw new Error("Missing return statement in function");
20763 }
20764
20765 final public ASTPragma Pragma() throws ParseException {
20766
20767 ASTPragma jjtn000 = new ASTPragma(this, JJTPRAGMA);
20768 boolean jjtc000 = true;
20769 jjtree.openNodeScope(jjtn000);
20770 try {
20771 jj_consume_token(PRAGMA);
20772 switch (jj_nt.kind) {
20773 case SERIALLY_REUSABLE:
20774 jj_consume_token(SERIALLY_REUSABLE);
20775 break;
20776 case AUTONOMOUS_TRANSACTION:
20777 jj_consume_token(AUTONOMOUS_TRANSACTION);
20778 break;
20779 case TIMESTAMP:
20780 jj_consume_token(TIMESTAMP);
20781 jj_consume_token(5);
20782 StringLiteral();
20783 jj_consume_token(7);
20784 break;
20785 case RESTRICT_REFERENCES:
20786 jj_consume_token(RESTRICT_REFERENCES);
20787 jj_consume_token(5);
20788 ID();
20789 label_66:
20790 while (true) {
20791 jj_consume_token(6);
20792 switch (jj_nt.kind) {
20793 case REPLACE:
20794 case DEFINER:
20795 case CURRENT_USER:
20796 case SERIALLY_REUSABLE:
20797 case RESTRICT_REFERENCES:
20798 case EXCEPTION_INIT:
20799 case AUTONOMOUS_TRANSACTION:
20800 case LANGUAGE:
20801 case ADD:
20802 case AGGREGATE:
20803 case ALL:
20804 case ALTER:
20805 case AND:
20806 case ANY:
20807 case ARRAY:
20808 case AS:
20809 case ASC:
20810 case AT:
20811 case ATTRIBUTE:
20812 case AUTHID:
20813 case AVG:
20814 case BETWEEN:
20815 case BINARY_INTEGER:
20816 case BODY:
20817 case BOOLEAN:
20818 case BULK:
20819 case BY:
20820 case BYTE:
20821 case CASCADE:
20822 case CASE:
20823 case CHAR:
20824 case CHAR_BASE:
20825 case CHECK:
20826 case CLOSE:
20827 case CLUSTER:
20828 case COALESCE:
20829 case COLLECT:
20830 case COLUMN:
20831 case COMMENT:
20832 case COMMIT:
20833 case COMPRESS:
20834 case CONNECT:
20835 case CONSTANT:
20836 case CONSTRUCTOR:
20837 case CONTINUE:
20838 case CONVERT:
20839 case CREATE:
20840 case CURRENT:
20841 case CURRVAL:
20842 case CURSOR:
20843 case DATA:
20844 case DATE:
20845 case DAY:
20846 case DECLARE:
20847 case DECIMAL:
20848 case _DEFAULT:
20849 case DELETE:
20850 case DESC:
20851 case DISABLE:
20852 case DISTINCT:
20853 case DO:
20854 case DROP:
20855 case EDITIONABLE:
20856 case ELEMENT:
20857 case ELSE:
20858 case ELSIF:
20859 case ENABLE:
20860 case ESCAPE:
20861 case EXCEPT:
20862 case EXCEPTION:
20863 case EXCEPTIONS:
20864 case EXCLUSIVE:
20865 case EXECUTE:
20866 case EXISTS:
20867 case EXIT:
20868 case EXTERNAL:
20869 case EXTENDS:
20870 case EXTRACT:
20871 case FALSE:
20872 case FETCH:
20873 case FINAL:
20874 case FLOAT:
20875 case FOR:
20876 case FORALL:
20877 case FORCE:
20878 case FROM:
20879 case FUNCTION:
20880 case GLOBAL:
20881 case GOTO:
20882 case GROUP:
20883 case HASH:
20884 case HAVING:
20885 case HEAP:
20886 case HOUR:
20887 case IF:
20888 case IMMEDIATE:
20889 case IN:
20890 case INDEX:
20891 case INDICES:
20892 case INDEXTYPE:
20893 case INDICATOR:
20894 case INSERT:
20895 case INSTANTIABLE:
20896 case INTEGER:
20897 case INTERFACE:
20898 case INTERSECT:
20899 case INTERVAL:
20900 case INTO:
20901 case INVALIDATE:
20902 case IS:
20903 case ISOLATION:
20904 case JAVA:
20905 case LEVEL:
20906 case LIKE:
20907 case LIMIT:
20908 case LIMITED:
20909 case LOCK:
20910 case LONG:
20911 case LOOP:
20912 case MAP:
20913 case MAX:
20914 case MEMBER:
20915 case MERGE:
20916 case MIN:
20917 case MINUS:
20918 case MINUTE:
20919 case MLSLABEL:
20920 case MODIFY:
20921 case MOD:
20922 case MODE:
20923 case MONTH:
20924 case NATURAL:
20925 case NATURALN:
20926 case NEW:
20927 case NEXTVAL:
20928 case NO:
20929 case NOCOPY:
20930 case NONEDITIONABLE:
20931 case NOT:
20932 case NOWAIT:
20933 case NULL:
20934 case NULLIF:
20935 case NUMBER:
20936 case BFILE_BASE:
20937 case BLOB_BASE:
20938 case CLOB_BASE:
20939 case DATE_BASE:
20940 case NUMBER_BASE:
20941 case OBJECT:
20942 case OCIROWID:
20943 case OF:
20944 case OID:
20945 case ON:
20946 case OPAQUE:
20947 case OPEN:
20948 case OPERATOR:
20949 case OPTION:
20950 case OR:
20951 case ORDER:
20952 case ORGANIZATION:
20953 case OTHERS:
20954 case OUT:
20955 case OVERRIDING:
20956 case PACKAGE:
20957 case PARTITION:
20958 case PCTFREE:
20959 case PLS_INTEGER:
20960 case POSITIVE:
20961 case POSITIVEN:
20962 case PRESERVE:
20963 case PRIOR:
20964 case PROMPT:
20965 case PRIVATE:
20966 case PROCEDURE:
20967 case PUBLIC:
20968 case RAISE:
20969 case RANGE:
20970 case RAW:
20971 case REAL:
20972 case RECORD:
20973 case REF:
20974 case RELEASE:
20975 case RELIES_ON:
20976 case RENAME:
20977 case RESULT:
20978 case RETURN:
20979 case RETURNING:
20980 case REVERSE:
20981 case ROLLBACK:
20982 case ROW:
20983 case ROWS:
20984 case ROWID:
20985 case ROWNUM:
20986 case ROWTYPE:
20987 case SAVE:
20988 case SAVEPOINT:
20989 case SECOND:
20990 case SELECT:
20991 case SELF:
20992 case SEPARATE:
20993 case SET:
20994 case SHARE:
20995 case SMALLINT:
20996 case SPACE:
20997 case SQL:
20998 case SQLCODE:
20999 case SQLERRM:
21000 case START:
21001 case STATIC:
21002 case STDDEV:
21003 case SUBTYPE:
21004 case SUBSTITUTABLE:
21005 case SUCCESSFUL:
21006 case SUM:
21007 case SYNONYM:
21008 case SYSDATE:
21009 case SYS_REFCURSOR:
21010 case TABLE:
21011 case TEMPORARY:
21012 case THEN:
21013 case TIME:
21014 case TIMESTAMP:
21015 case TIMEZONE_REGION:
21016 case TIMEZONE_ABBR:
21017 case TIMEZONE_MINUTE:
21018 case TIMEZONE_HOUR:
21019 case TO:
21020 case TRANSACTION:
21021 case TRIGGER:
21022 case TRUE:
21023 case TYPE:
21024 case UI:
21025 case UNDER:
21026 case USING:
21027 case WHILE:
21028 case YES:
21029 case SHOW:
21030 case A:
21031 case UPDATE:
21032 case VARCHAR:
21033 case VARCHAR2:
21034 case DOUBLE:
21035 case DEC:
21036 case PRECISION:
21037 case INT:
21038 case NUMERIC:
21039 case SIGNTYPE:
21040 case NCHAR:
21041 case NVARCHAR2:
21042 case STRING:
21043 case UROWID:
21044 case VARRAY:
21045 case VARYING:
21046 case BFILE:
21047 case BLOB:
21048 case CLOB:
21049 case NCLOB:
21050 case YEAR:
21051 case LOCAL:
21052 case WITH:
21053 case ZONE:
21054 case CHARACTER:
21055 case AFTER:
21056 case BEFORE:
21057 case OLD:
21058 case PARENT:
21059 case ANALYZE:
21060 case ASSOCIATE:
21061 case AUDIT:
21062 case COMPOUND:
21063 case DATABASE:
21064 case CALL:
21065 case DDL:
21066 case DISASSOCIATE:
21067 case EACH:
21068 case FOLLOWS:
21069 case LOGOFF:
21070 case LOGON:
21071 case NESTED:
21072 case NOAUDIT:
21073 case SCHEMA:
21074 case SERVERERROR:
21075 case SHUTDOWN:
21076 case STARTUP:
21077 case STATEMENT:
21078 case STATISTICS:
21079 case SUSPEND:
21080 case TRUNCATE:
21081 case WRAPPED:
21082 case LIBRARY:
21083 case NAME:
21084 case STRUCT:
21085 case CONTEXT:
21086 case PARAMETERS:
21087 case LENGTH:
21088 case TDO:
21089 case MAXLEN:
21090 case CHARSETID:
21091 case CHARSETFORM:
21092 case ACCEPT:
21093 case ACCESSIBLE:
21094 case COPY:
21095 case DEFINE:
21096 case DISCONNECT:
21097 case HOST:
21098 case PRINT:
21099 case QUIT:
21100 case REMARK:
21101 case UNDEFINE:
21102 case VARIABLE:
21103 case WHENEVER:
21104 case ATTACH:
21105 case CAST:
21106 case TREAT:
21107 case TRIM:
21108 case LEFT:
21109 case RIGHT:
21110 case BOTH:
21111 case EMPTY:
21112 case MULTISET:
21113 case SUBMULTISET:
21114 case LEADING:
21115 case TRAILING:
21116 case CHAR_CS:
21117 case NCHAR_CS:
21118 case DBTIMEZONE:
21119 case SESSIONTIMEZONE:
21120 case AUTHENTICATED:
21121 case LINK:
21122 case SHARED:
21123 case DIRECTORY:
21124 case USER:
21125 case IDENTIFIER:
21126 case QUOTED_LITERAL:
21127 case SQLDATA_CLASS:
21128 case CUSTOMDATUM_CLASS:
21129 case ORADATA_CLASS:
21130 case JAVA_INTERFACE_CLASS:
21131 ID();
21132 break;
21133 case STRING_LITERAL:
21134 StringLiteral();
21135 break;
21136 default:
21137 jj_la1[268] = jj_gen;
21138 jj_consume_token(-1);
21139 throw new ParseException();
21140 }
21141 switch (jj_nt.kind) {
21142 case 6:
21143 ;
21144 break;
21145 default:
21146 jj_la1[269] = jj_gen;
21147 break label_66;
21148 }
21149 }
21150 jj_consume_token(7);
21151 break;
21152 case EXCEPTION_INIT:
21153 jj_consume_token(EXCEPTION_INIT);
21154 jj_consume_token(5);
21155 jj_consume_token(IDENTIFIER);
21156 jj_consume_token(6);
21157 switch (jj_nt.kind) {
21158 case 16:
21159 case 17:
21160 switch (jj_nt.kind) {
21161 case 16:
21162 jj_consume_token(16);
21163 break;
21164 case 17:
21165 jj_consume_token(17);
21166 break;
21167 default:
21168 jj_la1[270] = jj_gen;
21169 jj_consume_token(-1);
21170 throw new ParseException();
21171 }
21172 break;
21173 default:
21174 jj_la1[271] = jj_gen;
21175 ;
21176 }
21177 NumericLiteral();
21178 jj_consume_token(7);
21179 break;
21180 case INTERFACE:
21181 jj_consume_token(INTERFACE);
21182 jj_consume_token(5);
21183 jj_consume_token(IDENTIFIER);
21184 jj_consume_token(6);
21185 ID();
21186 switch (jj_nt.kind) {
21187 case 6:
21188 jj_consume_token(6);
21189 NumericLiteral();
21190 break;
21191 default:
21192 jj_la1[272] = jj_gen;
21193 ;
21194 }
21195 jj_consume_token(7);
21196 break;
21197 case REPLACE:
21198 case DEFINER:
21199 case CURRENT_USER:
21200 case LANGUAGE:
21201 case ADD:
21202 case AGGREGATE:
21203 case ARRAY:
21204 case AT:
21205 case ATTRIBUTE:
21206 case AUTHID:
21207 case BODY:
21208 case BULK:
21209 case BYTE:
21210 case CASCADE:
21211 case CLOSE:
21212 case COALESCE:
21213 case COLLECT:
21214 case COLUMN:
21215 case COMMENT:
21216 case COMMIT:
21217 case CONSTRUCTOR:
21218 case CONTINUE:
21219 case CONVERT:
21220 case CURRENT:
21221 case CURSOR:
21222 case DATA:
21223 case DAY:
21224 case DISABLE:
21225 case EDITIONABLE:
21226 case ELEMENT:
21227 case ENABLE:
21228 case ESCAPE:
21229 case EXCEPT:
21230 case EXCEPTIONS:
21231 case EXIT:
21232 case EXTERNAL:
21233 case EXTENDS:
21234 case EXTRACT:
21235 case FALSE:
21236 case FINAL:
21237 case FORCE:
21238 case FUNCTION:
21239 case GLOBAL:
21240 case HASH:
21241 case HEAP:
21242 case HOUR:
21243 case IMMEDIATE:
21244 case INDICES:
21245 case INDEXTYPE:
21246 case INDICATOR:
21247 case INSTANTIABLE:
21248 case INTERVAL:
21249 case INVALIDATE:
21250 case ISOLATION:
21251 case JAVA:
21252 case LEVEL:
21253 case LIMIT:
21254 case LOOP:
21255 case MAP:
21256 case MAX:
21257 case MEMBER:
21258 case MERGE:
21259 case MIN:
21260 case MINUTE:
21261 case MLSLABEL:
21262 case MODIFY:
21263 case MOD:
21264 case MONTH:
21265 case NATURAL:
21266 case NEW:
21267 case NO:
21268 case NONEDITIONABLE:
21269 case NULLIF:
21270 case OBJECT:
21271 case OID:
21272 case OPAQUE:
21273 case OPEN:
21274 case OPERATOR:
21275 case ORGANIZATION:
21276 case OTHERS:
21277 case OVERRIDING:
21278 case PACKAGE:
21279 case PARTITION:
21280 case PRESERVE:
21281 case PRIVATE:
21282 case PROCEDURE:
21283 case RANGE:
21284 case RAW:
21285 case REAL:
21286 case RECORD:
21287 case REF:
21288 case RELEASE:
21289 case RELIES_ON:
21290 case RENAME:
21291 case RESULT:
21292 case RETURN:
21293 case RETURNING:
21294 case REVERSE:
21295 case ROLLBACK:
21296 case ROW:
21297 case ROWS:
21298 case ROWID:
21299 case ROWNUM:
21300 case SAVE:
21301 case SAVEPOINT:
21302 case SECOND:
21303 case SELF:
21304 case SET:
21305 case SPACE:
21306 case SQL:
21307 case SQLCODE:
21308 case SQLERRM:
21309 case STATIC:
21310 case SUBTYPE:
21311 case SUBSTITUTABLE:
21312 case SUCCESSFUL:
21313 case SYSDATE:
21314 case SYS_REFCURSOR:
21315 case TEMPORARY:
21316 case TIME:
21317 case TIMEZONE_REGION:
21318 case TIMEZONE_ABBR:
21319 case TIMEZONE_MINUTE:
21320 case TIMEZONE_HOUR:
21321 case TRANSACTION:
21322 case TRUE:
21323 case TYPE:
21324 case UNDER:
21325 case USING:
21326 case YES:
21327 case SHOW:
21328 case A:
21329 case DOUBLE:
21330 case DEC:
21331 case PRECISION:
21332 case INT:
21333 case NUMERIC:
21334 case NCHAR:
21335 case NVARCHAR2:
21336 case STRING:
21337 case UROWID:
21338 case VARRAY:
21339 case VARYING:
21340 case BFILE:
21341 case BLOB:
21342 case CLOB:
21343 case NCLOB:
21344 case YEAR:
21345 case LOCAL:
21346 case ZONE:
21347 case CHARACTER:
21348 case AFTER:
21349 case BEFORE:
21350 case OLD:
21351 case PARENT:
21352 case ANALYZE:
21353 case ASSOCIATE:
21354 case AUDIT:
21355 case COMPOUND:
21356 case DATABASE:
21357 case CALL:
21358 case DDL:
21359 case DISASSOCIATE:
21360 case EACH:
21361 case FOLLOWS:
21362 case LOGOFF:
21363 case LOGON:
21364 case NESTED:
21365 case NOAUDIT:
21366 case SCHEMA:
21367 case SERVERERROR:
21368 case SHUTDOWN:
21369 case STARTUP:
21370 case STATEMENT:
21371 case STATISTICS:
21372 case SUSPEND:
21373 case TRUNCATE:
21374 case WRAPPED:
21375 case LIBRARY:
21376 case NAME:
21377 case STRUCT:
21378 case CONTEXT:
21379 case PARAMETERS:
21380 case LENGTH:
21381 case TDO:
21382 case MAXLEN:
21383 case CHARSETID:
21384 case CHARSETFORM:
21385 case ACCEPT:
21386 case ACCESSIBLE:
21387 case COPY:
21388 case DEFINE:
21389 case DISCONNECT:
21390 case HOST:
21391 case PRINT:
21392 case QUIT:
21393 case REMARK:
21394 case UNDEFINE:
21395 case VARIABLE:
21396 case WHENEVER:
21397 case ATTACH:
21398 case CAST:
21399 case TREAT:
21400 case TRIM:
21401 case LEFT:
21402 case RIGHT:
21403 case BOTH:
21404 case EMPTY:
21405 case MULTISET:
21406 case SUBMULTISET:
21407 case LEADING:
21408 case TRAILING:
21409 case CHAR_CS:
21410 case NCHAR_CS:
21411 case DBTIMEZONE:
21412 case SESSIONTIMEZONE:
21413 case AUTHENTICATED:
21414 case LINK:
21415 case SHARED:
21416 case DIRECTORY:
21417 case USER:
21418 case IDENTIFIER:
21419 case QUOTED_LITERAL:
21420 QualifiedName();
21421 jj_consume_token(5);
21422 ReadPastNextOccurrence(")");
21423 break;
21424 default:
21425 jj_la1[273] = jj_gen;
21426 jj_consume_token(-1);
21427 throw new ParseException();
21428 }
21429 jj_consume_token(4);
21430 jjtree.closeNodeScope(jjtn000, true);
21431 jjtc000 = false;
21432 {if (true) return jjtn000 ;}
21433 } catch (Throwable jjte000) {
21434 if (jjtc000) {
21435 jjtree.clearNodeScope(jjtn000);
21436 jjtc000 = false;
21437 } else {
21438 jjtree.popNode();
21439 }
21440 if (jjte000 instanceof RuntimeException) {
21441 {if (true) throw (RuntimeException)jjte000;}
21442 }
21443 if (jjte000 instanceof ParseException) {
21444 {if (true) throw (ParseException)jjte000;}
21445 }
21446 {if (true) throw (Error)jjte000;}
21447 } finally {
21448 if (jjtc000) {
21449 jjtree.closeNodeScope(jjtn000, true);
21450 }
21451 }
21452 throw new Error("Missing return statement in function");
21453 }
21454
21455 final public ASTExceptionDeclaration ExceptionDeclaration() throws ParseException {
21456
21457 ASTExceptionDeclaration jjtn000 = new ASTExceptionDeclaration(this, JJTEXCEPTIONDECLARATION);
21458 boolean jjtc000 = true;
21459 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21460 try {
21461 simpleNode = ID();
21462 jj_consume_token(EXCEPTION);
21463 jj_consume_token(4);
21464 jjtree.closeNodeScope(jjtn000, true);
21465 jjtc000 = false;
21466 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
21467 } catch (Throwable jjte000) {
21468 if (jjtc000) {
21469 jjtree.clearNodeScope(jjtn000);
21470 jjtc000 = false;
21471 } else {
21472 jjtree.popNode();
21473 }
21474 if (jjte000 instanceof RuntimeException) {
21475 {if (true) throw (RuntimeException)jjte000;}
21476 }
21477 if (jjte000 instanceof ParseException) {
21478 {if (true) throw (ParseException)jjte000;}
21479 }
21480 {if (true) throw (Error)jjte000;}
21481 } finally {
21482 if (jjtc000) {
21483 jjtree.closeNodeScope(jjtn000, true);
21484 }
21485 }
21486 throw new Error("Missing return statement in function");
21487 }
21488
21489 final public ASTParallelClause ParallelClause() throws ParseException {
21490
21491 ASTParallelClause jjtn000 = new ASTParallelClause(this, JJTPARALLELCLAUSE);
21492 boolean jjtc000 = true;
21493 jjtree.openNodeScope(jjtn000);
21494 try {
21495 jj_consume_token(5);
21496 jj_consume_token(PARTITION);
21497 ID();
21498 jj_consume_token(BY);
21499 switch (jj_nt.kind) {
21500 case ANY:
21501 jj_consume_token(ANY);
21502 break;
21503 case HASH:
21504 case RANGE:
21505 switch (jj_nt.kind) {
21506 case HASH:
21507 jj_consume_token(HASH);
21508 break;
21509 case RANGE:
21510 jj_consume_token(RANGE);
21511 break;
21512 default:
21513 jj_la1[274] = jj_gen;
21514 jj_consume_token(-1);
21515 throw new ParseException();
21516 }
21517 jj_consume_token(5);
21518 ID();
21519 label_67:
21520 while (true) {
21521 switch (jj_nt.kind) {
21522 case 6:
21523 ;
21524 break;
21525 default:
21526 jj_la1[275] = jj_gen;
21527 break label_67;
21528 }
21529 jj_consume_token(6);
21530 ID();
21531 }
21532 jj_consume_token(7);
21533 break;
21534 default:
21535 jj_la1[276] = jj_gen;
21536 jj_consume_token(-1);
21537 throw new ParseException();
21538 }
21539 jj_consume_token(7);
21540 switch (jj_nt.kind) {
21541 case CLUSTER:
21542 case ORDER:
21543 switch (jj_nt.kind) {
21544 case ORDER:
21545 jj_consume_token(ORDER);
21546 break;
21547 case CLUSTER:
21548 jj_consume_token(CLUSTER);
21549 break;
21550 default:
21551 jj_la1[277] = jj_gen;
21552 jj_consume_token(-1);
21553 throw new ParseException();
21554 }
21555 jj_consume_token(BY);
21556 jj_consume_token(5);
21557 ID();
21558 label_68:
21559 while (true) {
21560 switch (jj_nt.kind) {
21561 case 6:
21562 ;
21563 break;
21564 default:
21565 jj_la1[278] = jj_gen;
21566 break label_68;
21567 }
21568 jj_consume_token(6);
21569 ID();
21570 }
21571 jj_consume_token(7);
21572 break;
21573 default:
21574 jj_la1[279] = jj_gen;
21575 ;
21576 }
21577 jjtree.closeNodeScope(jjtn000, true);
21578 jjtc000 = false;
21579 {if (true) return jjtn000 ;}
21580 } catch (Throwable jjte000) {
21581 if (jjtc000) {
21582 jjtree.clearNodeScope(jjtn000);
21583 jjtc000 = false;
21584 } else {
21585 jjtree.popNode();
21586 }
21587 if (jjte000 instanceof RuntimeException) {
21588 {if (true) throw (RuntimeException)jjte000;}
21589 }
21590 if (jjte000 instanceof ParseException) {
21591 {if (true) throw (ParseException)jjte000;}
21592 }
21593 {if (true) throw (Error)jjte000;}
21594 } finally {
21595 if (jjtc000) {
21596 jjtree.closeNodeScope(jjtn000, true);
21597 }
21598 }
21599 throw new Error("Missing return statement in function");
21600 }
21601
21602 final public ASTAccessibleByClause AccessibleByClause() throws ParseException {
21603
21604 ASTAccessibleByClause jjtn000 = new ASTAccessibleByClause(this, JJTACCESSIBLEBYCLAUSE);
21605 boolean jjtc000 = true;
21606 jjtree.openNodeScope(jjtn000);
21607 try {
21608 jj_consume_token(ACCESSIBLE);
21609 jj_consume_token(BY);
21610 jj_consume_token(5);
21611 switch (jj_nt.kind) {
21612 case FUNCTION:
21613 case PACKAGE:
21614 case PROCEDURE:
21615 case TRIGGER:
21616 case TYPE:
21617 switch (jj_nt.kind) {
21618 case FUNCTION:
21619 jj_consume_token(FUNCTION);
21620 break;
21621 case PROCEDURE:
21622 jj_consume_token(PROCEDURE);
21623 break;
21624 case PACKAGE:
21625 jj_consume_token(PACKAGE);
21626 break;
21627 case TRIGGER:
21628 jj_consume_token(TRIGGER);
21629 break;
21630 case TYPE:
21631 jj_consume_token(TYPE);
21632 break;
21633 default:
21634 jj_la1[280] = jj_gen;
21635 jj_consume_token(-1);
21636 throw new ParseException();
21637 }
21638 break;
21639 default:
21640 jj_la1[281] = jj_gen;
21641 ;
21642 }
21643 QualifiedName();
21644 label_69:
21645 while (true) {
21646 switch (jj_nt.kind) {
21647 case 6:
21648 ;
21649 break;
21650 default:
21651 jj_la1[282] = jj_gen;
21652 break label_69;
21653 }
21654 jj_consume_token(6);
21655 switch (jj_nt.kind) {
21656 case FUNCTION:
21657 case PACKAGE:
21658 case PROCEDURE:
21659 case TRIGGER:
21660 case TYPE:
21661 switch (jj_nt.kind) {
21662 case FUNCTION:
21663 jj_consume_token(FUNCTION);
21664 break;
21665 case PROCEDURE:
21666 jj_consume_token(PROCEDURE);
21667 break;
21668 case PACKAGE:
21669 jj_consume_token(PACKAGE);
21670 break;
21671 case TRIGGER:
21672 jj_consume_token(TRIGGER);
21673 break;
21674 case TYPE:
21675 jj_consume_token(TYPE);
21676 break;
21677 default:
21678 jj_la1[283] = jj_gen;
21679 jj_consume_token(-1);
21680 throw new ParseException();
21681 }
21682 break;
21683 default:
21684 jj_la1[284] = jj_gen;
21685 ;
21686 }
21687 QualifiedName();
21688 }
21689 jj_consume_token(7);
21690 jjtree.closeNodeScope(jjtn000, true);
21691 jjtc000 = false;
21692 {if (true) return jjtn000 ;}
21693 } catch (Throwable jjte000) {
21694 if (jjtc000) {
21695 jjtree.clearNodeScope(jjtn000);
21696 jjtc000 = false;
21697 } else {
21698 jjtree.popNode();
21699 }
21700 if (jjte000 instanceof RuntimeException) {
21701 {if (true) throw (RuntimeException)jjte000;}
21702 }
21703 if (jjte000 instanceof ParseException) {
21704 {if (true) throw (ParseException)jjte000;}
21705 }
21706 {if (true) throw (Error)jjte000;}
21707 } finally {
21708 if (jjtc000) {
21709 jjtree.closeNodeScope(jjtn000, true);
21710 }
21711 }
21712 throw new Error("Missing return statement in function");
21713 }
21714
21715
21716
21717
21718
21719
21720
21721
21722 final public ASTTable Table() throws ParseException {
21723
21724 ASTTable jjtn000 = new ASTTable(this, JJTTABLE);
21725 boolean jjtc000 = true;
21726 jjtree.openNodeScope(jjtn000);
21727 try {
21728 jj_consume_token(CREATE);
21729 switch (jj_nt.kind) {
21730 case GLOBAL:
21731 jj_consume_token(GLOBAL);
21732 jj_consume_token(TEMPORARY);
21733 break;
21734 default:
21735 jj_la1[285] = jj_gen;
21736 ;
21737 }
21738 jj_consume_token(TABLE);
21739 ObjectNameDeclaration();
21740 jj_consume_token(5);
21741 TableColumn();
21742 label_70:
21743 while (true) {
21744 switch (jj_nt.kind) {
21745 case 6:
21746 ;
21747 break;
21748 default:
21749 jj_la1[286] = jj_gen;
21750 break label_70;
21751 }
21752 jj_consume_token(6);
21753 TableColumn();
21754 }
21755 jj_consume_token(7);
21756 if (jj_2_58(2)) {
21757 jj_consume_token(ON);
21758 jj_consume_token(COMMIT);
21759 switch (jj_nt.kind) {
21760 case DELETE:
21761 jj_consume_token(DELETE);
21762 break;
21763 case PRESERVE:
21764 jj_consume_token(PRESERVE);
21765 break;
21766 default:
21767 jj_la1[287] = jj_gen;
21768 jj_consume_token(-1);
21769 throw new ParseException();
21770 }
21771 jj_consume_token(ROWS);
21772 } else {
21773 ;
21774 }
21775 switch (jj_nt.kind) {
21776 case 4:
21777 jj_consume_token(4);
21778 break;
21779 default:
21780 jj_la1[288] = jj_gen;
21781 ;
21782 }
21783 jjtree.closeNodeScope(jjtn000, true);
21784 jjtc000 = false;
21785 {if (true) return jjtn000 ;}
21786 } catch (Throwable jjte000) {
21787 if (jjtc000) {
21788 jjtree.clearNodeScope(jjtn000);
21789 jjtc000 = false;
21790 } else {
21791 jjtree.popNode();
21792 }
21793 if (jjte000 instanceof RuntimeException) {
21794 {if (true) throw (RuntimeException)jjte000;}
21795 }
21796 if (jjte000 instanceof ParseException) {
21797 {if (true) throw (ParseException)jjte000;}
21798 }
21799 {if (true) throw (Error)jjte000;}
21800 } finally {
21801 if (jjtc000) {
21802 jjtree.closeNodeScope(jjtn000, true);
21803 }
21804 }
21805 throw new Error("Missing return statement in function");
21806 }
21807
21808 final public ASTTableColumn TableColumn() throws ParseException {
21809
21810 ASTTableColumn jjtn000 = new ASTTableColumn(this, JJTTABLECOLUMN);
21811 boolean jjtc000 = true;
21812 jjtree.openNodeScope(jjtn000);
21813 try {
21814 ID();
21815 Datatype();
21816 switch (jj_nt.kind) {
21817 case _DEFAULT:
21818 jj_consume_token(_DEFAULT);
21819 Expression();
21820 break;
21821 default:
21822 jj_la1[289] = jj_gen;
21823 ;
21824 }
21825 switch (jj_nt.kind) {
21826 case NOT:
21827 case NULL:
21828 switch (jj_nt.kind) {
21829 case NOT:
21830 jj_consume_token(NOT);
21831 break;
21832 default:
21833 jj_la1[290] = jj_gen;
21834 ;
21835 }
21836 jj_consume_token(NULL);
21837 break;
21838 default:
21839 jj_la1[291] = jj_gen;
21840 ;
21841 }
21842 jjtree.closeNodeScope(jjtn000, true);
21843 jjtc000 = false;
21844 {if (true) return jjtn000 ;}
21845 } catch (Throwable jjte000) {
21846 if (jjtc000) {
21847 jjtree.clearNodeScope(jjtn000);
21848 jjtc000 = false;
21849 } else {
21850 jjtree.popNode();
21851 }
21852 if (jjte000 instanceof RuntimeException) {
21853 {if (true) throw (RuntimeException)jjte000;}
21854 }
21855 if (jjte000 instanceof ParseException) {
21856 {if (true) throw (ParseException)jjte000;}
21857 }
21858 {if (true) throw (Error)jjte000;}
21859 } finally {
21860 if (jjtc000) {
21861 jjtree.closeNodeScope(jjtn000, true);
21862 }
21863 }
21864 throw new Error("Missing return statement in function");
21865 }
21866
21867 final public ASTView View() throws ParseException {
21868
21869 ASTView jjtn000 = new ASTView(this, JJTVIEW);
21870 boolean jjtc000 = true;
21871 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21872 try {
21873 jj_consume_token(CREATE);
21874 switch (jj_nt.kind) {
21875 case OR:
21876 jj_consume_token(OR);
21877 jj_consume_token(REPLACE);
21878 break;
21879 default:
21880 jj_la1[292] = jj_gen;
21881 ;
21882 }
21883 switch (jj_nt.kind) {
21884 case FORCE:
21885 case NO:
21886 switch (jj_nt.kind) {
21887 case NO:
21888 jj_consume_token(NO);
21889 break;
21890 default:
21891 jj_la1[293] = jj_gen;
21892 ;
21893 }
21894 jj_consume_token(FORCE);
21895 break;
21896 default:
21897 jj_la1[294] = jj_gen;
21898 ;
21899 }
21900 jj_consume_token(VIEW);
21901 simpleNode = ObjectNameDeclaration();
21902 switch (jj_nt.kind) {
21903 case 5:
21904 jj_consume_token(5);
21905 ViewColumn();
21906 label_71:
21907 while (true) {
21908 switch (jj_nt.kind) {
21909 case 6:
21910 ;
21911 break;
21912 default:
21913 jj_la1[295] = jj_gen;
21914 break label_71;
21915 }
21916 jj_consume_token(6);
21917 ViewColumn();
21918 }
21919 jj_consume_token(7);
21920 break;
21921 default:
21922 jj_la1[296] = jj_gen;
21923 ;
21924 }
21925 jj_consume_token(AS);
21926 Statement();
21927 switch (jj_nt.kind) {
21928 case 4:
21929 jj_consume_token(4);
21930 break;
21931 case 1:
21932 jj_consume_token(1);
21933 break;
21934 default:
21935 jj_la1[297] = jj_gen;
21936 jj_consume_token(-1);
21937 throw new ParseException();
21938 }
21939 jjtree.closeNodeScope(jjtn000, true);
21940 jjtc000 = false;
21941 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
21942 } catch (Throwable jjte000) {
21943 if (jjtc000) {
21944 jjtree.clearNodeScope(jjtn000);
21945 jjtc000 = false;
21946 } else {
21947 jjtree.popNode();
21948 }
21949 if (jjte000 instanceof RuntimeException) {
21950 {if (true) throw (RuntimeException)jjte000;}
21951 }
21952 if (jjte000 instanceof ParseException) {
21953 {if (true) throw (ParseException)jjte000;}
21954 }
21955 {if (true) throw (Error)jjte000;}
21956 } finally {
21957 if (jjtc000) {
21958 jjtree.closeNodeScope(jjtn000, true);
21959 }
21960 }
21961 throw new Error("Missing return statement in function");
21962 }
21963
21964 final public ASTSynonym Synonym() throws ParseException {
21965
21966 ASTSynonym jjtn000 = new ASTSynonym(this, JJTSYNONYM);
21967 boolean jjtc000 = true;
21968 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
21969 try {
21970 jj_consume_token(CREATE);
21971 switch (jj_nt.kind) {
21972 case OR:
21973 jj_consume_token(OR);
21974 jj_consume_token(REPLACE);
21975 break;
21976 default:
21977 jj_la1[298] = jj_gen;
21978 ;
21979 }
21980 switch (jj_nt.kind) {
21981 case PUBLIC:
21982 jj_consume_token(PUBLIC);
21983 break;
21984 default:
21985 jj_la1[299] = jj_gen;
21986 ;
21987 }
21988 jj_consume_token(SYNONYM);
21989 simpleNode = ObjectNameDeclaration();
21990 jj_consume_token(FOR);
21991 ObjectNameDeclaration();
21992 switch (jj_nt.kind) {
21993 case 4:
21994 jj_consume_token(4);
21995 break;
21996 case 1:
21997 jj_consume_token(1);
21998 break;
21999 default:
22000 jj_la1[300] = jj_gen;
22001 jj_consume_token(-1);
22002 throw new ParseException();
22003 }
22004 jjtree.closeNodeScope(jjtn000, true);
22005 jjtc000 = false;
22006 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22007 } catch (Throwable jjte000) {
22008 if (jjtc000) {
22009 jjtree.clearNodeScope(jjtn000);
22010 jjtc000 = false;
22011 } else {
22012 jjtree.popNode();
22013 }
22014 if (jjte000 instanceof RuntimeException) {
22015 {if (true) throw (RuntimeException)jjte000;}
22016 }
22017 if (jjte000 instanceof ParseException) {
22018 {if (true) throw (ParseException)jjte000;}
22019 }
22020 {if (true) throw (Error)jjte000;}
22021 } finally {
22022 if (jjtc000) {
22023 jjtree.closeNodeScope(jjtn000, true);
22024 }
22025 }
22026 throw new Error("Missing return statement in function");
22027 }
22028
22029 final public ASTDirectory Directory() throws ParseException {
22030
22031 ASTDirectory jjtn000 = new ASTDirectory(this, JJTDIRECTORY);
22032 boolean jjtc000 = true;
22033 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22034 try {
22035 jj_consume_token(CREATE);
22036 switch (jj_nt.kind) {
22037 case OR:
22038 jj_consume_token(OR);
22039 jj_consume_token(REPLACE);
22040 break;
22041 default:
22042 jj_la1[301] = jj_gen;
22043 ;
22044 }
22045 jj_consume_token(DIRECTORY);
22046 simpleNode = ObjectNameDeclaration();
22047 jj_consume_token(AS);
22048 StringLiteral();
22049 switch (jj_nt.kind) {
22050 case 4:
22051 jj_consume_token(4);
22052 break;
22053 case 1:
22054 jj_consume_token(1);
22055 break;
22056 default:
22057 jj_la1[302] = jj_gen;
22058 jj_consume_token(-1);
22059 throw new ParseException();
22060 }
22061 jjtree.closeNodeScope(jjtn000, true);
22062 jjtc000 = false;
22063 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22064 } catch (Throwable jjte000) {
22065 if (jjtc000) {
22066 jjtree.clearNodeScope(jjtn000);
22067 jjtc000 = false;
22068 } else {
22069 jjtree.popNode();
22070 }
22071 if (jjte000 instanceof RuntimeException) {
22072 {if (true) throw (RuntimeException)jjte000;}
22073 }
22074 if (jjte000 instanceof ParseException) {
22075 {if (true) throw (ParseException)jjte000;}
22076 }
22077 {if (true) throw (Error)jjte000;}
22078 } finally {
22079 if (jjtc000) {
22080 jjtree.closeNodeScope(jjtn000, true);
22081 }
22082 }
22083 throw new Error("Missing return statement in function");
22084 }
22085
22086 final public ASTDatabaseLink DatabaseLink() throws ParseException {
22087
22088 ASTDatabaseLink jjtn000 = new ASTDatabaseLink(this, JJTDATABASELINK);
22089 boolean jjtc000 = true;
22090 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
22091 try {
22092 jj_consume_token(CREATE);
22093 switch (jj_nt.kind) {
22094 case SHARED:
22095 jj_consume_token(SHARED);
22096 break;
22097 default:
22098 jj_la1[303] = jj_gen;
22099 ;
22100 }
22101 switch (jj_nt.kind) {
22102 case PUBLIC:
22103 jj_consume_token(PUBLIC);
22104 break;
22105 default:
22106 jj_la1[304] = jj_gen;
22107 ;
22108 }
22109 jj_consume_token(DATABASE);
22110 jj_consume_token(LINK);
22111 simpleNode = ObjectNameDeclaration();
22112 switch (jj_nt.kind) {
22113 case CONNECT:
22114 jj_consume_token(CONNECT);
22115 jj_consume_token(TO);
22116 switch (jj_nt.kind) {
22117 case CURRENT_USER:
22118 jj_consume_token(CURRENT_USER);
22119 break;
22120 case REPLACE:
22121 case DEFINER:
22122 case LANGUAGE:
22123 case ADD:
22124 case AGGREGATE:
22125 case ARRAY:
22126 case AT:
22127 case ATTRIBUTE:
22128 case AUTHID:
22129 case BODY:
22130 case BULK:
22131 case BYTE:
22132 case CASCADE:
22133 case CLOSE:
22134 case COALESCE:
22135 case COLLECT:
22136 case COLUMN:
22137 case COMMENT:
22138 case COMMIT:
22139 case CONSTRUCTOR:
22140 case CONTINUE:
22141 case CONVERT:
22142 case CURRENT:
22143 case CURSOR:
22144 case DATA:
22145 case DAY:
22146 case DISABLE:
22147 case EDITIONABLE:
22148 case ELEMENT:
22149 case ENABLE:
22150 case ESCAPE:
22151 case EXCEPT:
22152 case EXCEPTIONS:
22153 case EXIT:
22154 case EXTERNAL:
22155 case EXTENDS:
22156 case EXTRACT:
22157 case FALSE:
22158 case FINAL:
22159 case FORCE:
22160 case FUNCTION:
22161 case GLOBAL:
22162 case HASH:
22163 case HEAP:
22164 case HOUR:
22165 case IMMEDIATE:
22166 case INDICES:
22167 case INDEXTYPE:
22168 case INDICATOR:
22169 case INSTANTIABLE:
22170 case INTERVAL:
22171 case INVALIDATE:
22172 case ISOLATION:
22173 case JAVA:
22174 case LEVEL:
22175 case LIMIT:
22176 case LOOP:
22177 case MAP:
22178 case MAX:
22179 case MEMBER:
22180 case MERGE:
22181 case MIN:
22182 case MINUTE:
22183 case MLSLABEL:
22184 case MODIFY:
22185 case MOD:
22186 case MONTH:
22187 case NATURAL:
22188 case NEW:
22189 case NO:
22190 case NONEDITIONABLE:
22191 case NULLIF:
22192 case OBJECT:
22193 case OID:
22194 case OPAQUE:
22195 case OPEN:
22196 case OPERATOR:
22197 case ORGANIZATION:
22198 case OTHERS:
22199 case OVERRIDING:
22200 case PACKAGE:
22201 case PARTITION:
22202 case PRESERVE:
22203 case PRIVATE:
22204 case PROCEDURE:
22205 case RANGE:
22206 case RAW:
22207 case REAL:
22208 case RECORD:
22209 case REF:
22210 case RELEASE:
22211 case RELIES_ON:
22212 case RENAME:
22213 case RESULT:
22214 case RETURN:
22215 case RETURNING:
22216 case REVERSE:
22217 case ROLLBACK:
22218 case ROW:
22219 case ROWS:
22220 case ROWID:
22221 case ROWNUM:
22222 case SAVE:
22223 case SAVEPOINT:
22224 case SECOND:
22225 case SELF:
22226 case SET:
22227 case SPACE:
22228 case SQL:
22229 case SQLCODE:
22230 case SQLERRM:
22231 case STATIC:
22232 case SUBTYPE:
22233 case SUBSTITUTABLE:
22234 case SUCCESSFUL:
22235 case SYSDATE:
22236 case SYS_REFCURSOR:
22237 case TEMPORARY:
22238 case TIME:
22239 case TIMESTAMP:
22240 case TIMEZONE_REGION:
22241 case TIMEZONE_ABBR:
22242 case TIMEZONE_MINUTE:
22243 case TIMEZONE_HOUR:
22244 case TRANSACTION:
22245 case TRUE:
22246 case TYPE:
22247 case UNDER:
22248 case USING:
22249 case YES:
22250 case SHOW:
22251 case A:
22252 case DOUBLE:
22253 case DEC:
22254 case PRECISION:
22255 case INT:
22256 case NUMERIC:
22257 case NCHAR:
22258 case NVARCHAR2:
22259 case STRING:
22260 case UROWID:
22261 case VARRAY:
22262 case VARYING:
22263 case BFILE:
22264 case BLOB:
22265 case CLOB:
22266 case NCLOB:
22267 case YEAR:
22268 case LOCAL:
22269 case ZONE:
22270 case CHARACTER:
22271 case AFTER:
22272 case BEFORE:
22273 case OLD:
22274 case PARENT:
22275 case ANALYZE:
22276 case ASSOCIATE:
22277 case AUDIT:
22278 case COMPOUND:
22279 case DATABASE:
22280 case CALL:
22281 case DDL:
22282 case DISASSOCIATE:
22283 case EACH:
22284 case FOLLOWS:
22285 case LOGOFF:
22286 case LOGON:
22287 case NESTED:
22288 case NOAUDIT:
22289 case SCHEMA:
22290 case SERVERERROR:
22291 case SHUTDOWN:
22292 case STARTUP:
22293 case STATEMENT:
22294 case STATISTICS:
22295 case SUSPEND:
22296 case TRUNCATE:
22297 case WRAPPED:
22298 case LIBRARY:
22299 case NAME:
22300 case STRUCT:
22301 case CONTEXT:
22302 case PARAMETERS:
22303 case LENGTH:
22304 case TDO:
22305 case MAXLEN:
22306 case CHARSETID:
22307 case CHARSETFORM:
22308 case ACCEPT:
22309 case ACCESSIBLE:
22310 case COPY:
22311 case DEFINE:
22312 case DISCONNECT:
22313 case HOST:
22314 case PRINT:
22315 case QUIT:
22316 case REMARK:
22317 case UNDEFINE:
22318 case VARIABLE:
22319 case WHENEVER:
22320 case ATTACH:
22321 case CAST:
22322 case TREAT:
22323 case TRIM:
22324 case LEFT:
22325 case RIGHT:
22326 case BOTH:
22327 case EMPTY:
22328 case MULTISET:
22329 case SUBMULTISET:
22330 case LEADING:
22331 case TRAILING:
22332 case CHAR_CS:
22333 case NCHAR_CS:
22334 case DBTIMEZONE:
22335 case SESSIONTIMEZONE:
22336 case AUTHENTICATED:
22337 case LINK:
22338 case SHARED:
22339 case DIRECTORY:
22340 case USER:
22341 case IDENTIFIER:
22342 case QUOTED_LITERAL:
22343 UnqualifiedID();
22344 jj_consume_token(IDENTIFIED);
22345 jj_consume_token(BY);
22346 UnqualifiedID();
22347 jj_consume_token(AUTHENTICATED);
22348 jj_consume_token(BY);
22349 UnqualifiedID();
22350 jj_consume_token(IDENTIFIED);
22351 jj_consume_token(BY);
22352 UnqualifiedID();
22353 break;
22354 default:
22355 jj_la1[305] = jj_gen;
22356 jj_consume_token(-1);
22357 throw new ParseException();
22358 }
22359 break;
22360 case REPLACE:
22361 case DEFINER:
22362 case CURRENT_USER:
22363 case LANGUAGE:
22364 case ADD:
22365 case AGGREGATE:
22366 case ARRAY:
22367 case AT:
22368 case ATTRIBUTE:
22369 case AUTHID:
22370 case BODY:
22371 case BULK:
22372 case BYTE:
22373 case CASCADE:
22374 case CLOSE:
22375 case COALESCE:
22376 case COLLECT:
22377 case COLUMN:
22378 case COMMENT:
22379 case COMMIT:
22380 case CONSTRUCTOR:
22381 case CONTINUE:
22382 case CONVERT:
22383 case CURRENT:
22384 case CURSOR:
22385 case DATA:
22386 case DAY:
22387 case DISABLE:
22388 case EDITIONABLE:
22389 case ELEMENT:
22390 case ENABLE:
22391 case ESCAPE:
22392 case EXCEPT:
22393 case EXCEPTIONS:
22394 case EXIT:
22395 case EXTERNAL:
22396 case EXTENDS:
22397 case EXTRACT:
22398 case FALSE:
22399 case FINAL:
22400 case FORCE:
22401 case FUNCTION:
22402 case GLOBAL:
22403 case HASH:
22404 case HEAP:
22405 case HOUR:
22406 case IMMEDIATE:
22407 case INDICES:
22408 case INDEXTYPE:
22409 case INDICATOR:
22410 case INSTANTIABLE:
22411 case INTERVAL:
22412 case INVALIDATE:
22413 case ISOLATION:
22414 case JAVA:
22415 case LEVEL:
22416 case LIMIT:
22417 case LOOP:
22418 case MAP:
22419 case MAX:
22420 case MEMBER:
22421 case MERGE:
22422 case MIN:
22423 case MINUTE:
22424 case MLSLABEL:
22425 case MODIFY:
22426 case MOD:
22427 case MONTH:
22428 case NATURAL:
22429 case NEW:
22430 case NO:
22431 case NONEDITIONABLE:
22432 case NULLIF:
22433 case OBJECT:
22434 case OID:
22435 case OPAQUE:
22436 case OPEN:
22437 case OPERATOR:
22438 case ORGANIZATION:
22439 case OTHERS:
22440 case OVERRIDING:
22441 case PACKAGE:
22442 case PARTITION:
22443 case PRESERVE:
22444 case PRIVATE:
22445 case PROCEDURE:
22446 case RANGE:
22447 case RAW:
22448 case REAL:
22449 case RECORD:
22450 case REF:
22451 case RELEASE:
22452 case RELIES_ON:
22453 case RENAME:
22454 case RESULT:
22455 case RETURN:
22456 case RETURNING:
22457 case REVERSE:
22458 case ROLLBACK:
22459 case ROW:
22460 case ROWS:
22461 case ROWID:
22462 case ROWNUM:
22463 case SAVE:
22464 case SAVEPOINT:
22465 case SECOND:
22466 case SELF:
22467 case SET:
22468 case SPACE:
22469 case SQL:
22470 case SQLCODE:
22471 case SQLERRM:
22472 case STATIC:
22473 case SUBTYPE:
22474 case SUBSTITUTABLE:
22475 case SUCCESSFUL:
22476 case SYSDATE:
22477 case SYS_REFCURSOR:
22478 case TEMPORARY:
22479 case TIME:
22480 case TIMESTAMP:
22481 case TIMEZONE_REGION:
22482 case TIMEZONE_ABBR:
22483 case TIMEZONE_MINUTE:
22484 case TIMEZONE_HOUR:
22485 case TRANSACTION:
22486 case TRUE:
22487 case TYPE:
22488 case UNDER:
22489 case USING:
22490 case YES:
22491 case SHOW:
22492 case A:
22493 case DOUBLE:
22494 case DEC:
22495 case PRECISION:
22496 case INT:
22497 case NUMERIC:
22498 case NCHAR:
22499 case NVARCHAR2:
22500 case STRING:
22501 case UROWID:
22502 case VARRAY:
22503 case VARYING:
22504 case BFILE:
22505 case BLOB:
22506 case CLOB:
22507 case NCLOB:
22508 case YEAR:
22509 case LOCAL:
22510 case ZONE:
22511 case CHARACTER:
22512 case AFTER:
22513 case BEFORE:
22514 case OLD:
22515 case PARENT:
22516 case ANALYZE:
22517 case ASSOCIATE:
22518 case AUDIT:
22519 case COMPOUND:
22520 case DATABASE:
22521 case CALL:
22522 case DDL:
22523 case DISASSOCIATE:
22524 case EACH:
22525 case FOLLOWS:
22526 case LOGOFF:
22527 case LOGON:
22528 case NESTED:
22529 case NOAUDIT:
22530 case SCHEMA:
22531 case SERVERERROR:
22532 case SHUTDOWN:
22533 case STARTUP:
22534 case STATEMENT:
22535 case STATISTICS:
22536 case SUSPEND:
22537 case TRUNCATE:
22538 case WRAPPED:
22539 case LIBRARY:
22540 case NAME:
22541 case STRUCT:
22542 case CONTEXT:
22543 case PARAMETERS:
22544 case LENGTH:
22545 case TDO:
22546 case MAXLEN:
22547 case CHARSETID:
22548 case CHARSETFORM:
22549 case ACCEPT:
22550 case ACCESSIBLE:
22551 case COPY:
22552 case DEFINE:
22553 case DISCONNECT:
22554 case HOST:
22555 case PRINT:
22556 case QUIT:
22557 case REMARK:
22558 case UNDEFINE:
22559 case VARIABLE:
22560 case WHENEVER:
22561 case ATTACH:
22562 case CAST:
22563 case TREAT:
22564 case TRIM:
22565 case LEFT:
22566 case RIGHT:
22567 case BOTH:
22568 case EMPTY:
22569 case MULTISET:
22570 case SUBMULTISET:
22571 case LEADING:
22572 case TRAILING:
22573 case CHAR_CS:
22574 case NCHAR_CS:
22575 case DBTIMEZONE:
22576 case SESSIONTIMEZONE:
22577 case AUTHENTICATED:
22578 case LINK:
22579 case SHARED:
22580 case DIRECTORY:
22581 case USER:
22582 case IDENTIFIER:
22583 case QUOTED_LITERAL:
22584 UnqualifiedID();
22585 jj_consume_token(IDENTIFIED);
22586 jj_consume_token(BY);
22587 UnqualifiedID();
22588 break;
22589 default:
22590 jj_la1[306] = jj_gen;
22591 jj_consume_token(-1);
22592 throw new ParseException();
22593 }
22594 switch (jj_nt.kind) {
22595 case USING:
22596 jj_consume_token(USING);
22597 StringLiteral();
22598 break;
22599 default:
22600 jj_la1[307] = jj_gen;
22601 ;
22602 }
22603 switch (jj_nt.kind) {
22604 case 4:
22605 jj_consume_token(4);
22606 break;
22607 case 1:
22608 jj_consume_token(1);
22609 break;
22610 default:
22611 jj_la1[308] = jj_gen;
22612 jj_consume_token(-1);
22613 throw new ParseException();
22614 }
22615 jjtree.closeNodeScope(jjtn000, true);
22616 jjtc000 = false;
22617 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
22618 } catch (Throwable jjte000) {
22619 if (jjtc000) {
22620 jjtree.clearNodeScope(jjtn000);
22621 jjtc000 = false;
22622 } else {
22623 jjtree.popNode();
22624 }
22625 if (jjte000 instanceof RuntimeException) {
22626 {if (true) throw (RuntimeException)jjte000;}
22627 }
22628 if (jjte000 instanceof ParseException) {
22629 {if (true) throw (ParseException)jjte000;}
22630 }
22631 {if (true) throw (Error)jjte000;}
22632 } finally {
22633 if (jjtc000) {
22634 jjtree.closeNodeScope(jjtn000, true);
22635 }
22636 }
22637 throw new Error("Missing return statement in function");
22638 }
22639
22640 final public ASTViewColumn ViewColumn() throws ParseException {
22641
22642 ASTViewColumn jjtn000 = new ASTViewColumn(this, JJTVIEWCOLUMN);
22643 boolean jjtc000 = true;
22644 jjtree.openNodeScope(jjtn000);
22645 try {
22646 ID();
22647 jjtree.closeNodeScope(jjtn000, true);
22648 jjtc000 = false;
22649 {if (true) return jjtn000 ;}
22650 } catch (Throwable jjte000) {
22651 if (jjtc000) {
22652 jjtree.clearNodeScope(jjtn000);
22653 jjtc000 = false;
22654 } else {
22655 jjtree.popNode();
22656 }
22657 if (jjte000 instanceof RuntimeException) {
22658 {if (true) throw (RuntimeException)jjte000;}
22659 }
22660 if (jjte000 instanceof ParseException) {
22661 {if (true) throw (ParseException)jjte000;}
22662 }
22663 {if (true) throw (Error)jjte000;}
22664 } finally {
22665 if (jjtc000) {
22666 jjtree.closeNodeScope(jjtn000, true);
22667 }
22668 }
22669 throw new Error("Missing return statement in function");
22670 }
22671
22672 final public ASTComment Comment() throws ParseException {
22673
22674 ASTComment jjtn000 = new ASTComment(this, JJTCOMMENT);
22675 boolean jjtc000 = true;
22676 jjtree.openNodeScope(jjtn000);
22677 try {
22678 jj_consume_token(COMMENT);
22679 jj_consume_token(ON);
22680 switch (jj_nt.kind) {
22681 case INDEXTYPE:
22682 case OPERATOR:
22683 case TABLE:
22684 switch (jj_nt.kind) {
22685 case TABLE:
22686 jj_consume_token(TABLE);
22687 break;
22688 case OPERATOR:
22689 jj_consume_token(OPERATOR);
22690 break;
22691 case INDEXTYPE:
22692 jj_consume_token(INDEXTYPE);
22693 break;
22694 default:
22695 jj_la1[309] = jj_gen;
22696 jj_consume_token(-1);
22697 throw new ParseException();
22698 }
22699 if (jj_2_59(2)) {
22700 ID();
22701 jj_consume_token(3);
22702 } else {
22703 ;
22704 }
22705 ID();
22706 break;
22707 case COLUMN:
22708 jj_consume_token(COLUMN);
22709 if (jj_2_60(2147483647)) {
22710 ID();
22711 jj_consume_token(3);
22712 } else {
22713 ;
22714 }
22715 ID();
22716 jj_consume_token(3);
22717 ID();
22718 break;
22719 default:
22720 jj_la1[310] = jj_gen;
22721 jj_consume_token(-1);
22722 throw new ParseException();
22723 }
22724 jj_consume_token(IS);
22725 jj_consume_token(STRING_LITERAL);
22726 switch (jj_nt.kind) {
22727 case 4:
22728 jj_consume_token(4);
22729 break;
22730 default:
22731 jj_la1[311] = jj_gen;
22732 ;
22733 }
22734 jjtree.closeNodeScope(jjtn000, true);
22735 jjtc000 = false;
22736 {if (true) return jjtn000 ;}
22737 } catch (Throwable jjte000) {
22738 if (jjtc000) {
22739 jjtree.clearNodeScope(jjtn000);
22740 jjtc000 = false;
22741 } else {
22742 jjtree.popNode();
22743 }
22744 if (jjte000 instanceof RuntimeException) {
22745 {if (true) throw (RuntimeException)jjte000;}
22746 }
22747 if (jjte000 instanceof ParseException) {
22748 {if (true) throw (ParseException)jjte000;}
22749 }
22750 {if (true) throw (Error)jjte000;}
22751 } finally {
22752 if (jjtc000) {
22753 jjtree.closeNodeScope(jjtn000, true);
22754 }
22755 }
22756 throw new Error("Missing return statement in function");
22757 }
22758
22759
22760 final public ASTTypeMethod TypeMethod() throws ParseException {
22761
22762 ASTTypeMethod jjtn000 = new ASTTypeMethod(this, JJTTYPEMETHOD);
22763 boolean jjtc000 = true;
22764 jjtree.openNodeScope(jjtn000);
22765 try {
22766 getToken(1);
22767
22768
22769 label_72:
22770 while (true) {
22771 switch (jj_nt.kind) {
22772 case FINAL:
22773 case INSTANTIABLE:
22774 case NOT:
22775 case OVERRIDING:
22776 ;
22777 break;
22778 default:
22779 jj_la1[312] = jj_gen;
22780 break label_72;
22781 }
22782 switch (jj_nt.kind) {
22783 case NOT:
22784 jj_consume_token(NOT);
22785 break;
22786 default:
22787 jj_la1[313] = jj_gen;
22788 ;
22789 }
22790 switch (jj_nt.kind) {
22791 case OVERRIDING:
22792 jj_consume_token(OVERRIDING);
22793 break;
22794 case INSTANTIABLE:
22795 jj_consume_token(INSTANTIABLE);
22796 break;
22797 case FINAL:
22798 jj_consume_token(FINAL);
22799 break;
22800 default:
22801 jj_la1[314] = jj_gen;
22802 jj_consume_token(-1);
22803 throw new ParseException();
22804 }
22805 }
22806 switch (jj_nt.kind) {
22807 case MAP:
22808 case ORDER:
22809 switch (jj_nt.kind) {
22810 case MAP:
22811 jj_consume_token(MAP);
22812 break;
22813 case ORDER:
22814 jj_consume_token(ORDER);
22815 break;
22816 default:
22817 jj_la1[315] = jj_gen;
22818 jj_consume_token(-1);
22819 throw new ParseException();
22820 }
22821 break;
22822 default:
22823 jj_la1[316] = jj_gen;
22824 ;
22825 }
22826 switch (jj_nt.kind) {
22827 case CONSTRUCTOR:
22828 jj_consume_token(CONSTRUCTOR);
22829 break;
22830 case MEMBER:
22831 jj_consume_token(MEMBER);
22832 break;
22833 case STATIC:
22834 jj_consume_token(STATIC);
22835 break;
22836 default:
22837 jj_la1[317] = jj_gen;
22838 jj_consume_token(-1);
22839 throw new ParseException();
22840 }
22841 MethodDeclarator();
22842 switch (jj_nt.kind) {
22843 case DETERMINISTIC:
22844 jj_consume_token(DETERMINISTIC);
22845 break;
22846 default:
22847 jj_la1[318] = jj_gen;
22848 ;
22849 }
22850 switch (jj_nt.kind) {
22851 case PARALLEL_ENABLE:
22852 jj_consume_token(PARALLEL_ENABLE);
22853 break;
22854 default:
22855 jj_la1[319] = jj_gen;
22856 ;
22857 }
22858 switch (jj_nt.kind) {
22859 case PIPELINED:
22860 jj_consume_token(PIPELINED);
22861 break;
22862 default:
22863 jj_la1[320] = jj_gen;
22864 ;
22865 }
22866 switch (jj_nt.kind) {
22867 case RESULT_CACHE:
22868 jj_consume_token(RESULT_CACHE);
22869 break;
22870 default:
22871 jj_la1[321] = jj_gen;
22872 ;
22873 }
22874 switch (jj_nt.kind) {
22875 case AS:
22876 case IS:
22877 switch (jj_nt.kind) {
22878 case IS:
22879 jj_consume_token(IS);
22880 break;
22881 case AS:
22882 jj_consume_token(AS);
22883 break;
22884 default:
22885 jj_la1[322] = jj_gen;
22886 jj_consume_token(-1);
22887 throw new ParseException();
22888 }
22889 switch (jj_nt.kind) {
22890 case LANGUAGE:
22891 case EXTERNAL:
22892 CallSpecTail();
22893 switch (jj_nt.kind) {
22894 case 4:
22895 jj_consume_token(4);
22896 break;
22897 default:
22898 jj_la1[323] = jj_gen;
22899 ;
22900 }
22901 break;
22902 case REPLACE:
22903 case DEFINER:
22904 case CURRENT_USER:
22905 case SERIALLY_REUSABLE:
22906 case RESTRICT_REFERENCES:
22907 case EXCEPTION_INIT:
22908 case AUTONOMOUS_TRANSACTION:
22909 case ADD:
22910 case AGGREGATE:
22911 case ALL:
22912 case ALTER:
22913 case AND:
22914 case ANY:
22915 case ARRAY:
22916 case AS:
22917 case ASC:
22918 case AT:
22919 case ATTRIBUTE:
22920 case AUTHID:
22921 case AVG:
22922 case BEGIN:
22923 case BETWEEN:
22924 case BINARY_INTEGER:
22925 case BODY:
22926 case BOOLEAN:
22927 case BULK:
22928 case BY:
22929 case BYTE:
22930 case CASCADE:
22931 case CASE:
22932 case CHAR:
22933 case CHAR_BASE:
22934 case CHECK:
22935 case CLOSE:
22936 case CLUSTER:
22937 case COALESCE:
22938 case COLLECT:
22939 case COLUMN:
22940 case COMMENT:
22941 case COMMIT:
22942 case COMPRESS:
22943 case CONNECT:
22944 case CONSTANT:
22945 case CONSTRUCTOR:
22946 case CONTINUE:
22947 case CONVERT:
22948 case CREATE:
22949 case CURRENT:
22950 case CURRVAL:
22951 case CURSOR:
22952 case DATA:
22953 case DATE:
22954 case DAY:
22955 case DECLARE:
22956 case DECIMAL:
22957 case _DEFAULT:
22958 case DELETE:
22959 case DESC:
22960 case DISABLE:
22961 case DISTINCT:
22962 case DO:
22963 case DROP:
22964 case EDITIONABLE:
22965 case ELEMENT:
22966 case ELSE:
22967 case ELSIF:
22968 case ENABLE:
22969 case ESCAPE:
22970 case EXCEPT:
22971 case EXCEPTION:
22972 case EXCEPTIONS:
22973 case EXCLUSIVE:
22974 case EXECUTE:
22975 case EXISTS:
22976 case EXIT:
22977 case EXTENDS:
22978 case EXTRACT:
22979 case FALSE:
22980 case FETCH:
22981 case FINAL:
22982 case FLOAT:
22983 case FOR:
22984 case FORALL:
22985 case FORCE:
22986 case FROM:
22987 case FUNCTION:
22988 case GLOBAL:
22989 case GOTO:
22990 case GROUP:
22991 case HASH:
22992 case HAVING:
22993 case HEAP:
22994 case HOUR:
22995 case IF:
22996 case IMMEDIATE:
22997 case IN:
22998 case INDEX:
22999 case INDICES:
23000 case INDEXTYPE:
23001 case INDICATOR:
23002 case INSERT:
23003 case INSTANTIABLE:
23004 case INTEGER:
23005 case INTERFACE:
23006 case INTERSECT:
23007 case INTERVAL:
23008 case INTO:
23009 case INVALIDATE:
23010 case IS:
23011 case ISOLATION:
23012 case JAVA:
23013 case LEVEL:
23014 case LIKE:
23015 case LIMIT:
23016 case LIMITED:
23017 case LOCK:
23018 case LONG:
23019 case LOOP:
23020 case MAP:
23021 case MAX:
23022 case MEMBER:
23023 case MERGE:
23024 case MIN:
23025 case MINUS:
23026 case MINUTE:
23027 case MLSLABEL:
23028 case MODIFY:
23029 case MOD:
23030 case MODE:
23031 case MONTH:
23032 case NATURAL:
23033 case NATURALN:
23034 case NEW:
23035 case NEXTVAL:
23036 case NO:
23037 case NOCOPY:
23038 case NONEDITIONABLE:
23039 case NOT:
23040 case NOWAIT:
23041 case NULL:
23042 case NULLIF:
23043 case NUMBER:
23044 case BFILE_BASE:
23045 case BLOB_BASE:
23046 case CLOB_BASE:
23047 case DATE_BASE:
23048 case NUMBER_BASE:
23049 case OBJECT:
23050 case OCIROWID:
23051 case OF:
23052 case OID:
23053 case ON:
23054 case OPAQUE:
23055 case OPEN:
23056 case OPERATOR:
23057 case OPTION:
23058 case OR:
23059 case ORDER:
23060 case ORGANIZATION:
23061 case OTHERS:
23062 case OUT:
23063 case OVERRIDING:
23064 case PACKAGE:
23065 case PARTITION:
23066 case PCTFREE:
23067 case PLS_INTEGER:
23068 case POSITIVE:
23069 case POSITIVEN:
23070 case PRAGMA:
23071 case PRESERVE:
23072 case PRIOR:
23073 case PROMPT:
23074 case PRIVATE:
23075 case PROCEDURE:
23076 case PUBLIC:
23077 case RAISE:
23078 case RANGE:
23079 case RAW:
23080 case REAL:
23081 case RECORD:
23082 case REF:
23083 case RELEASE:
23084 case RELIES_ON:
23085 case RENAME:
23086 case RESULT:
23087 case RETURN:
23088 case RETURNING:
23089 case REVERSE:
23090 case ROLLBACK:
23091 case ROW:
23092 case ROWS:
23093 case ROWID:
23094 case ROWNUM:
23095 case ROWTYPE:
23096 case SAVE:
23097 case SAVEPOINT:
23098 case SECOND:
23099 case SELECT:
23100 case SELF:
23101 case SEPARATE:
23102 case SET:
23103 case SHARE:
23104 case SMALLINT:
23105 case SPACE:
23106 case SQL:
23107 case SQLCODE:
23108 case SQLERRM:
23109 case START:
23110 case STATIC:
23111 case STDDEV:
23112 case SUBTYPE:
23113 case SUBSTITUTABLE:
23114 case SUCCESSFUL:
23115 case SUM:
23116 case SYNONYM:
23117 case SYSDATE:
23118 case SYS_REFCURSOR:
23119 case TABLE:
23120 case TEMPORARY:
23121 case THEN:
23122 case TIME:
23123 case TIMESTAMP:
23124 case TIMEZONE_REGION:
23125 case TIMEZONE_ABBR:
23126 case TIMEZONE_MINUTE:
23127 case TIMEZONE_HOUR:
23128 case TO:
23129 case TRANSACTION:
23130 case TRIGGER:
23131 case TRUE:
23132 case TYPE:
23133 case UI:
23134 case UNDER:
23135 case USING:
23136 case WHILE:
23137 case YES:
23138 case SHOW:
23139 case A:
23140 case UPDATE:
23141 case VARCHAR:
23142 case VARCHAR2:
23143 case DOUBLE:
23144 case DEC:
23145 case PRECISION:
23146 case INT:
23147 case NUMERIC:
23148 case SIGNTYPE:
23149 case NCHAR:
23150 case NVARCHAR2:
23151 case STRING:
23152 case UROWID:
23153 case VARRAY:
23154 case VARYING:
23155 case BFILE:
23156 case BLOB:
23157 case CLOB:
23158 case NCLOB:
23159 case YEAR:
23160 case LOCAL:
23161 case WITH:
23162 case ZONE:
23163 case CHARACTER:
23164 case AFTER:
23165 case BEFORE:
23166 case OLD:
23167 case PARENT:
23168 case CC_IF:
23169 case ANALYZE:
23170 case ASSOCIATE:
23171 case AUDIT:
23172 case COMPOUND:
23173 case DATABASE:
23174 case CALL:
23175 case DDL:
23176 case DISASSOCIATE:
23177 case EACH:
23178 case FOLLOWS:
23179 case LOGOFF:
23180 case LOGON:
23181 case NESTED:
23182 case NOAUDIT:
23183 case SCHEMA:
23184 case SERVERERROR:
23185 case SHUTDOWN:
23186 case STARTUP:
23187 case STATEMENT:
23188 case STATISTICS:
23189 case SUSPEND:
23190 case TRUNCATE:
23191 case WRAPPED:
23192 case LIBRARY:
23193 case NAME:
23194 case STRUCT:
23195 case CONTEXT:
23196 case PARAMETERS:
23197 case LENGTH:
23198 case TDO:
23199 case MAXLEN:
23200 case CHARSETID:
23201 case CHARSETFORM:
23202 case ACCEPT:
23203 case ACCESSIBLE:
23204 case COPY:
23205 case DEFINE:
23206 case DISCONNECT:
23207 case HOST:
23208 case PRINT:
23209 case QUIT:
23210 case REMARK:
23211 case UNDEFINE:
23212 case VARIABLE:
23213 case WHENEVER:
23214 case ATTACH:
23215 case CAST:
23216 case TREAT:
23217 case TRIM:
23218 case LEFT:
23219 case RIGHT:
23220 case BOTH:
23221 case EMPTY:
23222 case MULTISET:
23223 case SUBMULTISET:
23224 case LEADING:
23225 case TRAILING:
23226 case CHAR_CS:
23227 case NCHAR_CS:
23228 case DBTIMEZONE:
23229 case SESSIONTIMEZONE:
23230 case AUTHENTICATED:
23231 case LINK:
23232 case SHARED:
23233 case DIRECTORY:
23234 case USER:
23235 case IDENTIFIER:
23236 case QUOTED_LITERAL:
23237 case SQLDATA_CLASS:
23238 case CUSTOMDATUM_CLASS:
23239 case ORADATA_CLASS:
23240 case JAVA_INTERFACE_CLASS:
23241 DeclarativeSection();
23242 jj_consume_token(BEGIN);
23243 label_73:
23244 while (true) {
23245 switch (jj_nt.kind) {
23246 case 5:
23247 case 16:
23248 case 17:
23249 case 21:
23250 case REPLACE:
23251 case DEFINER:
23252 case CURRENT_USER:
23253 case LANGUAGE:
23254 case ADD:
23255 case AGGREGATE:
23256 case ARRAY:
23257 case AT:
23258 case ATTRIBUTE:
23259 case AUTHID:
23260 case BEGIN:
23261 case BODY:
23262 case BULK:
23263 case BYTE:
23264 case CASCADE:
23265 case CASE:
23266 case CLOSE:
23267 case COALESCE:
23268 case COLLECT:
23269 case COLUMN:
23270 case COMMENT:
23271 case COMMIT:
23272 case CONSTRUCTOR:
23273 case CONTINUE:
23274 case CONVERT:
23275 case CURRENT:
23276 case CURSOR:
23277 case DATA:
23278 case DATE:
23279 case DAY:
23280 case DECLARE:
23281 case DELETE:
23282 case DISABLE:
23283 case EDITIONABLE:
23284 case ELEMENT:
23285 case ENABLE:
23286 case ESCAPE:
23287 case EXCEPT:
23288 case EXCEPTIONS:
23289 case EXECUTE:
23290 case EXIT:
23291 case EXTERNAL:
23292 case EXTENDS:
23293 case EXTRACT:
23294 case FALSE:
23295 case FETCH:
23296 case FINAL:
23297 case FOR:
23298 case FORALL:
23299 case FORCE:
23300 case FUNCTION:
23301 case GLOBAL:
23302 case GOTO:
23303 case HASH:
23304 case HEAP:
23305 case HOUR:
23306 case IF:
23307 case IMMEDIATE:
23308 case INDICES:
23309 case INDEXTYPE:
23310 case INDICATOR:
23311 case INSERT:
23312 case INSTANTIABLE:
23313 case INTERVAL:
23314 case INVALIDATE:
23315 case ISOLATION:
23316 case JAVA:
23317 case LEVEL:
23318 case LIMIT:
23319 case LOCK:
23320 case LOOP:
23321 case MAP:
23322 case MAX:
23323 case MEMBER:
23324 case MERGE:
23325 case MIN:
23326 case MINUTE:
23327 case MLSLABEL:
23328 case MODIFY:
23329 case MOD:
23330 case MONTH:
23331 case NATURAL:
23332 case NEW:
23333 case NEW_DOT:
23334 case NO:
23335 case NONEDITIONABLE:
23336 case NOT:
23337 case NULL:
23338 case NULLIF:
23339 case OBJECT:
23340 case OID:
23341 case OPAQUE:
23342 case OPEN:
23343 case OPERATOR:
23344 case ORGANIZATION:
23345 case OTHERS:
23346 case OVERRIDING:
23347 case PACKAGE:
23348 case PARTITION:
23349 case PIPE:
23350 case PRESERVE:
23351 case PRIVATE:
23352 case PROCEDURE:
23353 case RAISE:
23354 case RANGE:
23355 case RAW:
23356 case REAL:
23357 case RECORD:
23358 case REF:
23359 case RELEASE:
23360 case RELIES_ON:
23361 case RENAME:
23362 case RESULT:
23363 case RETURN:
23364 case RETURNING:
23365 case REVERSE:
23366 case ROLLBACK:
23367 case ROW:
23368 case ROWS:
23369 case ROWID:
23370 case ROWNUM:
23371 case SAVE:
23372 case SAVEPOINT:
23373 case SECOND:
23374 case SELECT:
23375 case SELF:
23376 case SET:
23377 case SPACE:
23378 case SQL:
23379 case SQLCODE:
23380 case SQLERRM:
23381 case STATIC:
23382 case SUBTYPE:
23383 case SUBSTITUTABLE:
23384 case SUCCESSFUL:
23385 case SYSDATE:
23386 case SYS_REFCURSOR:
23387 case TEMPORARY:
23388 case TIME:
23389 case TIMESTAMP:
23390 case TIMEZONE_REGION:
23391 case TIMEZONE_ABBR:
23392 case TIMEZONE_MINUTE:
23393 case TIMEZONE_HOUR:
23394 case TRANSACTION:
23395 case TRUE:
23396 case TYPE:
23397 case UNDER:
23398 case USING:
23399 case WHILE:
23400 case YES:
23401 case SHOW:
23402 case A:
23403 case UPDATE:
23404 case DOUBLE:
23405 case DEC:
23406 case PRECISION:
23407 case INT:
23408 case NUMERIC:
23409 case NCHAR:
23410 case NVARCHAR2:
23411 case STRING:
23412 case UROWID:
23413 case VARRAY:
23414 case VARYING:
23415 case BFILE:
23416 case BLOB:
23417 case CLOB:
23418 case NCLOB:
23419 case YEAR:
23420 case LOCAL:
23421 case WITH:
23422 case ZONE:
23423 case CHARACTER:
23424 case AFTER:
23425 case BEFORE:
23426 case OLD:
23427 case PARENT:
23428 case CC_IF:
23429 case CC_ERROR:
23430 case ANALYZE:
23431 case ASSOCIATE:
23432 case AUDIT:
23433 case COMPOUND:
23434 case DATABASE:
23435 case CALL:
23436 case DDL:
23437 case DISASSOCIATE:
23438 case EACH:
23439 case FOLLOWS:
23440 case LOGOFF:
23441 case LOGON:
23442 case NESTED:
23443 case NOAUDIT:
23444 case SCHEMA:
23445 case SERVERERROR:
23446 case SHUTDOWN:
23447 case STARTUP:
23448 case STATEMENT:
23449 case STATISTICS:
23450 case SUSPEND:
23451 case TRUNCATE:
23452 case WRAPPED:
23453 case LIBRARY:
23454 case NAME:
23455 case STRUCT:
23456 case CONTEXT:
23457 case PARAMETERS:
23458 case LENGTH:
23459 case TDO:
23460 case MAXLEN:
23461 case CHARSETID:
23462 case CHARSETFORM:
23463 case ACCEPT:
23464 case ACCESSIBLE:
23465 case COPY:
23466 case DEFINE:
23467 case DISCONNECT:
23468 case HOST:
23469 case PRINT:
23470 case QUIT:
23471 case REMARK:
23472 case UNDEFINE:
23473 case VARIABLE:
23474 case WHENEVER:
23475 case ATTACH:
23476 case CAST:
23477 case TREAT:
23478 case TRIM:
23479 case LEFT:
23480 case RIGHT:
23481 case BOTH:
23482 case EMPTY:
23483 case MULTISET:
23484 case SUBMULTISET:
23485 case LEADING:
23486 case TRAILING:
23487 case CHAR_CS:
23488 case NCHAR_CS:
23489 case DBTIMEZONE:
23490 case SESSIONTIMEZONE:
23491 case AUTHENTICATED:
23492 case LINK:
23493 case SHARED:
23494 case DIRECTORY:
23495 case USER:
23496 case IDENTIFIER:
23497 case UNSIGNED_NUMERIC_LITERAL:
23498 case CHARACTER_LITERAL:
23499 case STRING_LITERAL:
23500 case QUOTED_LITERAL:
23501 ;
23502 break;
23503 default:
23504 jj_la1[324] = jj_gen;
23505 break label_73;
23506 }
23507 Statement();
23508 }
23509 switch (jj_nt.kind) {
23510 case EXCEPTION:
23511 ExceptionHandler();
23512 break;
23513 default:
23514 jj_la1[325] = jj_gen;
23515 ;
23516 }
23517 jj_consume_token(END);
23518 switch (jj_nt.kind) {
23519 case REPLACE:
23520 case DEFINER:
23521 case CURRENT_USER:
23522 case SERIALLY_REUSABLE:
23523 case RESTRICT_REFERENCES:
23524 case EXCEPTION_INIT:
23525 case AUTONOMOUS_TRANSACTION:
23526 case LANGUAGE:
23527 case ADD:
23528 case AGGREGATE:
23529 case ALL:
23530 case ALTER:
23531 case AND:
23532 case ANY:
23533 case ARRAY:
23534 case AS:
23535 case ASC:
23536 case AT:
23537 case ATTRIBUTE:
23538 case AUTHID:
23539 case AVG:
23540 case BETWEEN:
23541 case BINARY_INTEGER:
23542 case BODY:
23543 case BOOLEAN:
23544 case BULK:
23545 case BY:
23546 case BYTE:
23547 case CASCADE:
23548 case CASE:
23549 case CHAR:
23550 case CHAR_BASE:
23551 case CHECK:
23552 case CLOSE:
23553 case CLUSTER:
23554 case COALESCE:
23555 case COLLECT:
23556 case COLUMN:
23557 case COMMENT:
23558 case COMMIT:
23559 case COMPRESS:
23560 case CONNECT:
23561 case CONSTANT:
23562 case CONSTRUCTOR:
23563 case CONTINUE:
23564 case CONVERT:
23565 case CREATE:
23566 case CURRENT:
23567 case CURRVAL:
23568 case CURSOR:
23569 case DATA:
23570 case DATE:
23571 case DAY:
23572 case DECLARE:
23573 case DECIMAL:
23574 case _DEFAULT:
23575 case DELETE:
23576 case DESC:
23577 case DISABLE:
23578 case DISTINCT:
23579 case DO:
23580 case DROP:
23581 case EDITIONABLE:
23582 case ELEMENT:
23583 case ELSE:
23584 case ELSIF:
23585 case ENABLE:
23586 case ESCAPE:
23587 case EXCEPT:
23588 case EXCEPTION:
23589 case EXCEPTIONS:
23590 case EXCLUSIVE:
23591 case EXECUTE:
23592 case EXISTS:
23593 case EXIT:
23594 case EXTERNAL:
23595 case EXTENDS:
23596 case EXTRACT:
23597 case FALSE:
23598 case FETCH:
23599 case FINAL:
23600 case FLOAT:
23601 case FOR:
23602 case FORALL:
23603 case FORCE:
23604 case FROM:
23605 case FUNCTION:
23606 case GLOBAL:
23607 case GOTO:
23608 case GROUP:
23609 case HASH:
23610 case HAVING:
23611 case HEAP:
23612 case HOUR:
23613 case IF:
23614 case IMMEDIATE:
23615 case IN:
23616 case INDEX:
23617 case INDICES:
23618 case INDEXTYPE:
23619 case INDICATOR:
23620 case INSERT:
23621 case INSTANTIABLE:
23622 case INTEGER:
23623 case INTERFACE:
23624 case INTERSECT:
23625 case INTERVAL:
23626 case INTO:
23627 case INVALIDATE:
23628 case IS:
23629 case ISOLATION:
23630 case JAVA:
23631 case LEVEL:
23632 case LIKE:
23633 case LIMIT:
23634 case LIMITED:
23635 case LOCK:
23636 case LONG:
23637 case LOOP:
23638 case MAP:
23639 case MAX:
23640 case MEMBER:
23641 case MERGE:
23642 case MIN:
23643 case MINUS:
23644 case MINUTE:
23645 case MLSLABEL:
23646 case MODIFY:
23647 case MOD:
23648 case MODE:
23649 case MONTH:
23650 case NATURAL:
23651 case NATURALN:
23652 case NEW:
23653 case NEXTVAL:
23654 case NO:
23655 case NOCOPY:
23656 case NONEDITIONABLE:
23657 case NOT:
23658 case NOWAIT:
23659 case NULL:
23660 case NULLIF:
23661 case NUMBER:
23662 case BFILE_BASE:
23663 case BLOB_BASE:
23664 case CLOB_BASE:
23665 case DATE_BASE:
23666 case NUMBER_BASE:
23667 case OBJECT:
23668 case OCIROWID:
23669 case OF:
23670 case OID:
23671 case ON:
23672 case OPAQUE:
23673 case OPEN:
23674 case OPERATOR:
23675 case OPTION:
23676 case OR:
23677 case ORDER:
23678 case ORGANIZATION:
23679 case OTHERS:
23680 case OUT:
23681 case OVERRIDING:
23682 case PACKAGE:
23683 case PARTITION:
23684 case PCTFREE:
23685 case PLS_INTEGER:
23686 case POSITIVE:
23687 case POSITIVEN:
23688 case PRESERVE:
23689 case PRIOR:
23690 case PROMPT:
23691 case PRIVATE:
23692 case PROCEDURE:
23693 case PUBLIC:
23694 case RAISE:
23695 case RANGE:
23696 case RAW:
23697 case REAL:
23698 case RECORD:
23699 case REF:
23700 case RELEASE:
23701 case RELIES_ON:
23702 case RENAME:
23703 case RESULT:
23704 case RETURN:
23705 case RETURNING:
23706 case REVERSE:
23707 case ROLLBACK:
23708 case ROW:
23709 case ROWS:
23710 case ROWID:
23711 case ROWNUM:
23712 case ROWTYPE:
23713 case SAVE:
23714 case SAVEPOINT:
23715 case SECOND:
23716 case SELECT:
23717 case SELF:
23718 case SEPARATE:
23719 case SET:
23720 case SHARE:
23721 case SMALLINT:
23722 case SPACE:
23723 case SQL:
23724 case SQLCODE:
23725 case SQLERRM:
23726 case START:
23727 case STATIC:
23728 case STDDEV:
23729 case SUBTYPE:
23730 case SUBSTITUTABLE:
23731 case SUCCESSFUL:
23732 case SUM:
23733 case SYNONYM:
23734 case SYSDATE:
23735 case SYS_REFCURSOR:
23736 case TABLE:
23737 case TEMPORARY:
23738 case THEN:
23739 case TIME:
23740 case TIMESTAMP:
23741 case TIMEZONE_REGION:
23742 case TIMEZONE_ABBR:
23743 case TIMEZONE_MINUTE:
23744 case TIMEZONE_HOUR:
23745 case TO:
23746 case TRANSACTION:
23747 case TRIGGER:
23748 case TRUE:
23749 case TYPE:
23750 case UI:
23751 case UNDER:
23752 case USING:
23753 case WHILE:
23754 case YES:
23755 case SHOW:
23756 case A:
23757 case UPDATE:
23758 case VARCHAR:
23759 case VARCHAR2:
23760 case DOUBLE:
23761 case DEC:
23762 case PRECISION:
23763 case INT:
23764 case NUMERIC:
23765 case SIGNTYPE:
23766 case NCHAR:
23767 case NVARCHAR2:
23768 case STRING:
23769 case UROWID:
23770 case VARRAY:
23771 case VARYING:
23772 case BFILE:
23773 case BLOB:
23774 case CLOB:
23775 case NCLOB:
23776 case YEAR:
23777 case LOCAL:
23778 case WITH:
23779 case ZONE:
23780 case CHARACTER:
23781 case AFTER:
23782 case BEFORE:
23783 case OLD:
23784 case PARENT:
23785 case ANALYZE:
23786 case ASSOCIATE:
23787 case AUDIT:
23788 case COMPOUND:
23789 case DATABASE:
23790 case CALL:
23791 case DDL:
23792 case DISASSOCIATE:
23793 case EACH:
23794 case FOLLOWS:
23795 case LOGOFF:
23796 case LOGON:
23797 case NESTED:
23798 case NOAUDIT:
23799 case SCHEMA:
23800 case SERVERERROR:
23801 case SHUTDOWN:
23802 case STARTUP:
23803 case STATEMENT:
23804 case STATISTICS:
23805 case SUSPEND:
23806 case TRUNCATE:
23807 case WRAPPED:
23808 case LIBRARY:
23809 case NAME:
23810 case STRUCT:
23811 case CONTEXT:
23812 case PARAMETERS:
23813 case LENGTH:
23814 case TDO:
23815 case MAXLEN:
23816 case CHARSETID:
23817 case CHARSETFORM:
23818 case ACCEPT:
23819 case ACCESSIBLE:
23820 case COPY:
23821 case DEFINE:
23822 case DISCONNECT:
23823 case HOST:
23824 case PRINT:
23825 case QUIT:
23826 case REMARK:
23827 case UNDEFINE:
23828 case VARIABLE:
23829 case WHENEVER:
23830 case ATTACH:
23831 case CAST:
23832 case TREAT:
23833 case TRIM:
23834 case LEFT:
23835 case RIGHT:
23836 case BOTH:
23837 case EMPTY:
23838 case MULTISET:
23839 case SUBMULTISET:
23840 case LEADING:
23841 case TRAILING:
23842 case CHAR_CS:
23843 case NCHAR_CS:
23844 case DBTIMEZONE:
23845 case SESSIONTIMEZONE:
23846 case AUTHENTICATED:
23847 case LINK:
23848 case SHARED:
23849 case DIRECTORY:
23850 case USER:
23851 case IDENTIFIER:
23852 case QUOTED_LITERAL:
23853 case SQLDATA_CLASS:
23854 case CUSTOMDATUM_CLASS:
23855 case ORADATA_CLASS:
23856 case JAVA_INTERFACE_CLASS:
23857 ID();
23858 break;
23859 default:
23860 jj_la1[326] = jj_gen;
23861 ;
23862 }
23863 jj_consume_token(4);
23864 break;
23865 default:
23866 jj_la1[327] = jj_gen;
23867 jj_consume_token(-1);
23868 throw new ParseException();
23869 }
23870 break;
23871 default:
23872 jj_la1[328] = jj_gen;
23873 ;
23874 }
23875 jjtree.closeNodeScope(jjtn000, true);
23876 jjtc000 = false;
23877 {if (true) return jjtn000 ;}
23878 } catch (Throwable jjte000) {
23879 if (jjtc000) {
23880 jjtree.clearNodeScope(jjtn000);
23881 jjtc000 = false;
23882 } else {
23883 jjtree.popNode();
23884 }
23885 if (jjte000 instanceof RuntimeException) {
23886 {if (true) throw (RuntimeException)jjte000;}
23887 }
23888 if (jjte000 instanceof ParseException) {
23889 {if (true) throw (ParseException)jjte000;}
23890 }
23891 {if (true) throw (Error)jjte000;}
23892 } finally {
23893 if (jjtc000) {
23894 jjtree.closeNodeScope(jjtn000, true);
23895 }
23896 }
23897 throw new Error("Missing return statement in function");
23898 }
23899
23900 final public ASTTypeSpecification TypeSpecification() throws ParseException {
23901
23902 ASTTypeSpecification jjtn000 = new ASTTypeSpecification(this, JJTTYPESPECIFICATION);
23903 boolean jjtc000 = true;
23904 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
23905 try {
23906 switch (jj_nt.kind) {
23907 case CREATE:
23908 jj_consume_token(CREATE);
23909 switch (jj_nt.kind) {
23910 case OR:
23911 jj_consume_token(OR);
23912 jj_consume_token(REPLACE);
23913 break;
23914 default:
23915 jj_la1[329] = jj_gen;
23916 ;
23917 }
23918 switch (jj_nt.kind) {
23919 case EDITIONABLE:
23920 case NONEDITIONABLE:
23921 switch (jj_nt.kind) {
23922 case EDITIONABLE:
23923 jj_consume_token(EDITIONABLE);
23924 break;
23925 case NONEDITIONABLE:
23926 jj_consume_token(NONEDITIONABLE);
23927 break;
23928 default:
23929 jj_la1[330] = jj_gen;
23930 jj_consume_token(-1);
23931 throw new ParseException();
23932 }
23933 break;
23934 default:
23935 jj_la1[331] = jj_gen;
23936 ;
23937 }
23938 break;
23939 default:
23940 jj_la1[332] = jj_gen;
23941 ;
23942 }
23943 jj_consume_token(TYPE);
23944 simpleNode = ObjectNameDeclaration();
23945 switch (jj_nt.kind) {
23946 case FORCE:
23947 jj_consume_token(FORCE);
23948 break;
23949 default:
23950 jj_la1[333] = jj_gen;
23951 ;
23952 }
23953 if (jj_2_61(2)) {
23954 jj_consume_token(OID);
23955 jj_consume_token(STRING_LITERAL);
23956 } else {
23957 ;
23958 }
23959 label_74:
23960 while (true) {
23961 if (jj_2_62(2)) {
23962 ;
23963 } else {
23964 break label_74;
23965 }
23966 switch (jj_nt.kind) {
23967 case AUTHID:
23968 jj_consume_token(AUTHID);
23969 switch (jj_nt.kind) {
23970 case CURRENT_USER:
23971 jj_consume_token(CURRENT_USER);
23972 break;
23973 case DEFINER:
23974 jj_consume_token(DEFINER);
23975 break;
23976 default:
23977 jj_la1[334] = jj_gen;
23978 jj_consume_token(-1);
23979 throw new ParseException();
23980 }
23981 break;
23982 case ACCESSIBLE:
23983 AccessibleByClause();
23984 break;
23985 default:
23986 jj_la1[335] = jj_gen;
23987 jj_consume_token(-1);
23988 throw new ParseException();
23989 }
23990 }
23991 switch (jj_nt.kind) {
23992 case AS:
23993 case IS:
23994 case UNDER:
23995 switch (jj_nt.kind) {
23996 case UNDER:
23997 jj_consume_token(UNDER);
23998 ObjectNameDeclaration();
23999 break;
24000 default:
24001 jj_la1[342] = jj_gen;
24002 if (jj_2_63(2)) {
24003 switch (jj_nt.kind) {
24004 case IS:
24005 jj_consume_token(IS);
24006 break;
24007 case AS:
24008 jj_consume_token(AS);
24009 break;
24010 default:
24011 jj_la1[336] = jj_gen;
24012 jj_consume_token(-1);
24013 throw new ParseException();
24014 }
24015 jj_consume_token(OBJECT);
24016 } else if (jj_2_64(2)) {
24017 switch (jj_nt.kind) {
24018 case IS:
24019 jj_consume_token(IS);
24020 break;
24021 case AS:
24022 jj_consume_token(AS);
24023 break;
24024 default:
24025 jj_la1[337] = jj_gen;
24026 jj_consume_token(-1);
24027 throw new ParseException();
24028 }
24029 jj_consume_token(OPAQUE);
24030 jj_consume_token(VARYING);
24031 jj_consume_token(24);
24032 jj_consume_token(USING);
24033 jj_consume_token(LIBRARY);
24034 switch (jj_nt.kind) {
24035 case IDENTIFIER:
24036 jj_consume_token(IDENTIFIER);
24037 break;
24038 case QUOTED_LITERAL:
24039 jj_consume_token(QUOTED_LITERAL);
24040 break;
24041 case STRING_LITERAL:
24042 StringLiteral();
24043 break;
24044 default:
24045 jj_la1[338] = jj_gen;
24046 jj_consume_token(-1);
24047 throw new ParseException();
24048 }
24049 switch (jj_nt.kind) {
24050 case 3:
24051 jj_consume_token(3);
24052 switch (jj_nt.kind) {
24053 case IDENTIFIER:
24054 jj_consume_token(IDENTIFIER);
24055 break;
24056 case QUOTED_LITERAL:
24057 jj_consume_token(QUOTED_LITERAL);
24058 break;
24059 case STRING_LITERAL:
24060 StringLiteral();
24061 break;
24062 default:
24063 jj_la1[339] = jj_gen;
24064 jj_consume_token(-1);
24065 throw new ParseException();
24066 }
24067 break;
24068 default:
24069 jj_la1[340] = jj_gen;
24070 ;
24071 }
24072 } else if (jj_2_65(2)) {
24073 switch (jj_nt.kind) {
24074 case IS:
24075 jj_consume_token(IS);
24076 break;
24077 case AS:
24078 jj_consume_token(AS);
24079 break;
24080 default:
24081 jj_la1[341] = jj_gen;
24082 jj_consume_token(-1);
24083 throw new ParseException();
24084 }
24085 CollectionTypeName();
24086 jj_consume_token(OF);
24087 Datatype();
24088 } else {
24089 jj_consume_token(-1);
24090 throw new ParseException();
24091 }
24092 }
24093 break;
24094 default:
24095 jj_la1[343] = jj_gen;
24096 ;
24097 }
24098 if (jj_2_66(8)) {
24099 jj_consume_token(EXTERNAL);
24100 jj_consume_token(IDENTIFIER);
24101 jj_consume_token(IDENTIFIER);
24102 jj_consume_token(LANGUAGE);
24103 jj_consume_token(JAVA);
24104 jj_consume_token(USING);
24105 jj_consume_token(IDENTIFIER);
24106 } else {
24107 ;
24108 }
24109 switch (jj_nt.kind) {
24110 case WRAPPED:
24111 WrappedObject();
24112 break;
24113 default:
24114 jj_la1[344] = jj_gen;
24115 ;
24116 }
24117 switch (jj_nt.kind) {
24118 case 5:
24119 jj_consume_token(5);
24120 label_75:
24121 while (true) {
24122 switch (jj_nt.kind) {
24123 case REPLACE:
24124 case DEFINER:
24125 case CURRENT_USER:
24126 case SERIALLY_REUSABLE:
24127 case RESTRICT_REFERENCES:
24128 case EXCEPTION_INIT:
24129 case AUTONOMOUS_TRANSACTION:
24130 case LANGUAGE:
24131 case ADD:
24132 case AGGREGATE:
24133 case ALL:
24134 case ALTER:
24135 case AND:
24136 case ANY:
24137 case ARRAY:
24138 case AS:
24139 case ASC:
24140 case AT:
24141 case ATTRIBUTE:
24142 case AUTHID:
24143 case AVG:
24144 case BETWEEN:
24145 case BINARY_INTEGER:
24146 case BODY:
24147 case BOOLEAN:
24148 case BULK:
24149 case BY:
24150 case BYTE:
24151 case CASCADE:
24152 case CASE:
24153 case CHAR:
24154 case CHAR_BASE:
24155 case CHECK:
24156 case CLOSE:
24157 case CLUSTER:
24158 case COALESCE:
24159 case COLLECT:
24160 case COLUMN:
24161 case COMMENT:
24162 case COMMIT:
24163 case COMPRESS:
24164 case CONNECT:
24165 case CONSTANT:
24166 case CONSTRUCTOR:
24167 case CONTINUE:
24168 case CONVERT:
24169 case CREATE:
24170 case CURRENT:
24171 case CURRVAL:
24172 case CURSOR:
24173 case DATA:
24174 case DATE:
24175 case DAY:
24176 case DECLARE:
24177 case DECIMAL:
24178 case _DEFAULT:
24179 case DELETE:
24180 case DESC:
24181 case DISABLE:
24182 case DISTINCT:
24183 case DO:
24184 case DROP:
24185 case EDITIONABLE:
24186 case ELEMENT:
24187 case ELSE:
24188 case ELSIF:
24189 case ENABLE:
24190 case ESCAPE:
24191 case EXCEPT:
24192 case EXCEPTION:
24193 case EXCEPTIONS:
24194 case EXCLUSIVE:
24195 case EXECUTE:
24196 case EXISTS:
24197 case EXIT:
24198 case EXTERNAL:
24199 case EXTENDS:
24200 case EXTRACT:
24201 case FALSE:
24202 case FETCH:
24203 case FINAL:
24204 case FLOAT:
24205 case FOR:
24206 case FORALL:
24207 case FORCE:
24208 case FROM:
24209 case FUNCTION:
24210 case GLOBAL:
24211 case GOTO:
24212 case GROUP:
24213 case HASH:
24214 case HAVING:
24215 case HEAP:
24216 case HOUR:
24217 case IF:
24218 case IMMEDIATE:
24219 case IN:
24220 case INDEX:
24221 case INDICES:
24222 case INDEXTYPE:
24223 case INDICATOR:
24224 case INSERT:
24225 case INSTANTIABLE:
24226 case INTEGER:
24227 case INTERFACE:
24228 case INTERSECT:
24229 case INTERVAL:
24230 case INTO:
24231 case INVALIDATE:
24232 case IS:
24233 case ISOLATION:
24234 case JAVA:
24235 case LEVEL:
24236 case LIKE:
24237 case LIMIT:
24238 case LIMITED:
24239 case LOCK:
24240 case LONG:
24241 case LOOP:
24242 case MAP:
24243 case MAX:
24244 case MEMBER:
24245 case MERGE:
24246 case MIN:
24247 case MINUS:
24248 case MINUTE:
24249 case MLSLABEL:
24250 case MODIFY:
24251 case MOD:
24252 case MODE:
24253 case MONTH:
24254 case NATURAL:
24255 case NATURALN:
24256 case NEW:
24257 case NEXTVAL:
24258 case NO:
24259 case NOCOPY:
24260 case NONEDITIONABLE:
24261 case NOT:
24262 case NOWAIT:
24263 case NULL:
24264 case NULLIF:
24265 case NUMBER:
24266 case BFILE_BASE:
24267 case BLOB_BASE:
24268 case CLOB_BASE:
24269 case DATE_BASE:
24270 case NUMBER_BASE:
24271 case OBJECT:
24272 case OCIROWID:
24273 case OF:
24274 case OID:
24275 case ON:
24276 case OPAQUE:
24277 case OPEN:
24278 case OPERATOR:
24279 case OPTION:
24280 case OR:
24281 case ORDER:
24282 case ORGANIZATION:
24283 case OTHERS:
24284 case OUT:
24285 case OVERRIDING:
24286 case PACKAGE:
24287 case PARTITION:
24288 case PCTFREE:
24289 case PLS_INTEGER:
24290 case POSITIVE:
24291 case POSITIVEN:
24292 case PRAGMA:
24293 case PRESERVE:
24294 case PRIOR:
24295 case PROMPT:
24296 case PRIVATE:
24297 case PROCEDURE:
24298 case PUBLIC:
24299 case RAISE:
24300 case RANGE:
24301 case RAW:
24302 case REAL:
24303 case RECORD:
24304 case REF:
24305 case RELEASE:
24306 case RELIES_ON:
24307 case RENAME:
24308 case RESULT:
24309 case RETURN:
24310 case RETURNING:
24311 case REVERSE:
24312 case ROLLBACK:
24313 case ROW:
24314 case ROWS:
24315 case ROWID:
24316 case ROWNUM:
24317 case ROWTYPE:
24318 case SAVE:
24319 case SAVEPOINT:
24320 case SECOND:
24321 case SELECT:
24322 case SELF:
24323 case SEPARATE:
24324 case SET:
24325 case SHARE:
24326 case SMALLINT:
24327 case SPACE:
24328 case SQL:
24329 case SQLCODE:
24330 case SQLERRM:
24331 case START:
24332 case STATIC:
24333 case STDDEV:
24334 case SUBTYPE:
24335 case SUBSTITUTABLE:
24336 case SUCCESSFUL:
24337 case SUM:
24338 case SYNONYM:
24339 case SYSDATE:
24340 case SYS_REFCURSOR:
24341 case TABLE:
24342 case TEMPORARY:
24343 case THEN:
24344 case TIME:
24345 case TIMESTAMP:
24346 case TIMEZONE_REGION:
24347 case TIMEZONE_ABBR:
24348 case TIMEZONE_MINUTE:
24349 case TIMEZONE_HOUR:
24350 case TO:
24351 case TRANSACTION:
24352 case TRIGGER:
24353 case TRUE:
24354 case TYPE:
24355 case UI:
24356 case UNDER:
24357 case USING:
24358 case WHILE:
24359 case YES:
24360 case SHOW:
24361 case A:
24362 case UPDATE:
24363 case VARCHAR:
24364 case VARCHAR2:
24365 case DOUBLE:
24366 case DEC:
24367 case PRECISION:
24368 case INT:
24369 case NUMERIC:
24370 case SIGNTYPE:
24371 case NCHAR:
24372 case NVARCHAR2:
24373 case STRING:
24374 case UROWID:
24375 case VARRAY:
24376 case VARYING:
24377 case BFILE:
24378 case BLOB:
24379 case CLOB:
24380 case NCLOB:
24381 case YEAR:
24382 case LOCAL:
24383 case WITH:
24384 case ZONE:
24385 case CHARACTER:
24386 case AFTER:
24387 case BEFORE:
24388 case OLD:
24389 case PARENT:
24390 case ANALYZE:
24391 case ASSOCIATE:
24392 case AUDIT:
24393 case COMPOUND:
24394 case DATABASE:
24395 case CALL:
24396 case DDL:
24397 case DISASSOCIATE:
24398 case EACH:
24399 case FOLLOWS:
24400 case LOGOFF:
24401 case LOGON:
24402 case NESTED:
24403 case NOAUDIT:
24404 case SCHEMA:
24405 case SERVERERROR:
24406 case SHUTDOWN:
24407 case STARTUP:
24408 case STATEMENT:
24409 case STATISTICS:
24410 case SUSPEND:
24411 case TRUNCATE:
24412 case WRAPPED:
24413 case LIBRARY:
24414 case NAME:
24415 case STRUCT:
24416 case CONTEXT:
24417 case PARAMETERS:
24418 case LENGTH:
24419 case TDO:
24420 case MAXLEN:
24421 case CHARSETID:
24422 case CHARSETFORM:
24423 case ACCEPT:
24424 case ACCESSIBLE:
24425 case COPY:
24426 case DEFINE:
24427 case DISCONNECT:
24428 case HOST:
24429 case PRINT:
24430 case QUIT:
24431 case REMARK:
24432 case UNDEFINE:
24433 case VARIABLE:
24434 case WHENEVER:
24435 case ATTACH:
24436 case CAST:
24437 case TREAT:
24438 case TRIM:
24439 case LEFT:
24440 case RIGHT:
24441 case BOTH:
24442 case EMPTY:
24443 case MULTISET:
24444 case SUBMULTISET:
24445 case LEADING:
24446 case TRAILING:
24447 case CHAR_CS:
24448 case NCHAR_CS:
24449 case DBTIMEZONE:
24450 case SESSIONTIMEZONE:
24451 case AUTHENTICATED:
24452 case LINK:
24453 case SHARED:
24454 case DIRECTORY:
24455 case USER:
24456 case IDENTIFIER:
24457 case QUOTED_LITERAL:
24458 case SQLDATA_CLASS:
24459 case CUSTOMDATUM_CLASS:
24460 case ORADATA_CLASS:
24461 case JAVA_INTERFACE_CLASS:
24462 ;
24463 break;
24464 default:
24465 jj_la1[345] = jj_gen;
24466 break label_75;
24467 }
24468 if (jj_2_67(2)) {
24469 TypeMethod();
24470 } else {
24471 switch (jj_nt.kind) {
24472 case REPLACE:
24473 case DEFINER:
24474 case CURRENT_USER:
24475 case SERIALLY_REUSABLE:
24476 case RESTRICT_REFERENCES:
24477 case EXCEPTION_INIT:
24478 case AUTONOMOUS_TRANSACTION:
24479 case LANGUAGE:
24480 case ADD:
24481 case AGGREGATE:
24482 case ALL:
24483 case ALTER:
24484 case AND:
24485 case ANY:
24486 case ARRAY:
24487 case AS:
24488 case ASC:
24489 case AT:
24490 case ATTRIBUTE:
24491 case AUTHID:
24492 case AVG:
24493 case BETWEEN:
24494 case BINARY_INTEGER:
24495 case BODY:
24496 case BOOLEAN:
24497 case BULK:
24498 case BY:
24499 case BYTE:
24500 case CASCADE:
24501 case CASE:
24502 case CHAR:
24503 case CHAR_BASE:
24504 case CHECK:
24505 case CLOSE:
24506 case CLUSTER:
24507 case COALESCE:
24508 case COLLECT:
24509 case COLUMN:
24510 case COMMENT:
24511 case COMMIT:
24512 case COMPRESS:
24513 case CONNECT:
24514 case CONSTANT:
24515 case CONSTRUCTOR:
24516 case CONTINUE:
24517 case CONVERT:
24518 case CREATE:
24519 case CURRENT:
24520 case CURRVAL:
24521 case CURSOR:
24522 case DATA:
24523 case DATE:
24524 case DAY:
24525 case DECLARE:
24526 case DECIMAL:
24527 case _DEFAULT:
24528 case DELETE:
24529 case DESC:
24530 case DISABLE:
24531 case DISTINCT:
24532 case DO:
24533 case DROP:
24534 case EDITIONABLE:
24535 case ELEMENT:
24536 case ELSE:
24537 case ELSIF:
24538 case ENABLE:
24539 case ESCAPE:
24540 case EXCEPT:
24541 case EXCEPTION:
24542 case EXCEPTIONS:
24543 case EXCLUSIVE:
24544 case EXECUTE:
24545 case EXISTS:
24546 case EXIT:
24547 case EXTERNAL:
24548 case EXTENDS:
24549 case EXTRACT:
24550 case FALSE:
24551 case FETCH:
24552 case FINAL:
24553 case FLOAT:
24554 case FOR:
24555 case FORALL:
24556 case FORCE:
24557 case FROM:
24558 case FUNCTION:
24559 case GLOBAL:
24560 case GOTO:
24561 case GROUP:
24562 case HASH:
24563 case HAVING:
24564 case HEAP:
24565 case HOUR:
24566 case IF:
24567 case IMMEDIATE:
24568 case IN:
24569 case INDEX:
24570 case INDICES:
24571 case INDEXTYPE:
24572 case INDICATOR:
24573 case INSERT:
24574 case INSTANTIABLE:
24575 case INTEGER:
24576 case INTERFACE:
24577 case INTERSECT:
24578 case INTERVAL:
24579 case INTO:
24580 case INVALIDATE:
24581 case IS:
24582 case ISOLATION:
24583 case JAVA:
24584 case LEVEL:
24585 case LIKE:
24586 case LIMIT:
24587 case LIMITED:
24588 case LOCK:
24589 case LONG:
24590 case LOOP:
24591 case MAP:
24592 case MAX:
24593 case MEMBER:
24594 case MERGE:
24595 case MIN:
24596 case MINUS:
24597 case MINUTE:
24598 case MLSLABEL:
24599 case MODIFY:
24600 case MOD:
24601 case MODE:
24602 case MONTH:
24603 case NATURAL:
24604 case NATURALN:
24605 case NEW:
24606 case NEXTVAL:
24607 case NO:
24608 case NOCOPY:
24609 case NONEDITIONABLE:
24610 case NOT:
24611 case NOWAIT:
24612 case NULL:
24613 case NULLIF:
24614 case NUMBER:
24615 case BFILE_BASE:
24616 case BLOB_BASE:
24617 case CLOB_BASE:
24618 case DATE_BASE:
24619 case NUMBER_BASE:
24620 case OBJECT:
24621 case OCIROWID:
24622 case OF:
24623 case OID:
24624 case ON:
24625 case OPAQUE:
24626 case OPEN:
24627 case OPERATOR:
24628 case OPTION:
24629 case OR:
24630 case ORDER:
24631 case ORGANIZATION:
24632 case OTHERS:
24633 case OUT:
24634 case OVERRIDING:
24635 case PACKAGE:
24636 case PARTITION:
24637 case PCTFREE:
24638 case PLS_INTEGER:
24639 case POSITIVE:
24640 case POSITIVEN:
24641 case PRESERVE:
24642 case PRIOR:
24643 case PROMPT:
24644 case PRIVATE:
24645 case PROCEDURE:
24646 case PUBLIC:
24647 case RAISE:
24648 case RANGE:
24649 case RAW:
24650 case REAL:
24651 case RECORD:
24652 case REF:
24653 case RELEASE:
24654 case RELIES_ON:
24655 case RENAME:
24656 case RESULT:
24657 case RETURN:
24658 case RETURNING:
24659 case REVERSE:
24660 case ROLLBACK:
24661 case ROW:
24662 case ROWS:
24663 case ROWID:
24664 case ROWNUM:
24665 case ROWTYPE:
24666 case SAVE:
24667 case SAVEPOINT:
24668 case SECOND:
24669 case SELECT:
24670 case SELF:
24671 case SEPARATE:
24672 case SET:
24673 case SHARE:
24674 case SMALLINT:
24675 case SPACE:
24676 case SQL:
24677 case SQLCODE:
24678 case SQLERRM:
24679 case START:
24680 case STATIC:
24681 case STDDEV:
24682 case SUBTYPE:
24683 case SUBSTITUTABLE:
24684 case SUCCESSFUL:
24685 case SUM:
24686 case SYNONYM:
24687 case SYSDATE:
24688 case SYS_REFCURSOR:
24689 case TABLE:
24690 case TEMPORARY:
24691 case THEN:
24692 case TIME:
24693 case TIMESTAMP:
24694 case TIMEZONE_REGION:
24695 case TIMEZONE_ABBR:
24696 case TIMEZONE_MINUTE:
24697 case TIMEZONE_HOUR:
24698 case TO:
24699 case TRANSACTION:
24700 case TRIGGER:
24701 case TRUE:
24702 case TYPE:
24703 case UI:
24704 case UNDER:
24705 case USING:
24706 case WHILE:
24707 case YES:
24708 case SHOW:
24709 case A:
24710 case UPDATE:
24711 case VARCHAR:
24712 case VARCHAR2:
24713 case DOUBLE:
24714 case DEC:
24715 case PRECISION:
24716 case INT:
24717 case NUMERIC:
24718 case SIGNTYPE:
24719 case NCHAR:
24720 case NVARCHAR2:
24721 case STRING:
24722 case UROWID:
24723 case VARRAY:
24724 case VARYING:
24725 case BFILE:
24726 case BLOB:
24727 case CLOB:
24728 case NCLOB:
24729 case YEAR:
24730 case LOCAL:
24731 case WITH:
24732 case ZONE:
24733 case CHARACTER:
24734 case AFTER:
24735 case BEFORE:
24736 case OLD:
24737 case PARENT:
24738 case ANALYZE:
24739 case ASSOCIATE:
24740 case AUDIT:
24741 case COMPOUND:
24742 case DATABASE:
24743 case CALL:
24744 case DDL:
24745 case DISASSOCIATE:
24746 case EACH:
24747 case FOLLOWS:
24748 case LOGOFF:
24749 case LOGON:
24750 case NESTED:
24751 case NOAUDIT:
24752 case SCHEMA:
24753 case SERVERERROR:
24754 case SHUTDOWN:
24755 case STARTUP:
24756 case STATEMENT:
24757 case STATISTICS:
24758 case SUSPEND:
24759 case TRUNCATE:
24760 case WRAPPED:
24761 case LIBRARY:
24762 case NAME:
24763 case STRUCT:
24764 case CONTEXT:
24765 case PARAMETERS:
24766 case LENGTH:
24767 case TDO:
24768 case MAXLEN:
24769 case CHARSETID:
24770 case CHARSETFORM:
24771 case ACCEPT:
24772 case ACCESSIBLE:
24773 case COPY:
24774 case DEFINE:
24775 case DISCONNECT:
24776 case HOST:
24777 case PRINT:
24778 case QUIT:
24779 case REMARK:
24780 case UNDEFINE:
24781 case VARIABLE:
24782 case WHENEVER:
24783 case ATTACH:
24784 case CAST:
24785 case TREAT:
24786 case TRIM:
24787 case LEFT:
24788 case RIGHT:
24789 case BOTH:
24790 case EMPTY:
24791 case MULTISET:
24792 case SUBMULTISET:
24793 case LEADING:
24794 case TRAILING:
24795 case CHAR_CS:
24796 case NCHAR_CS:
24797 case DBTIMEZONE:
24798 case SESSIONTIMEZONE:
24799 case AUTHENTICATED:
24800 case LINK:
24801 case SHARED:
24802 case DIRECTORY:
24803 case USER:
24804 case IDENTIFIER:
24805 case QUOTED_LITERAL:
24806 case SQLDATA_CLASS:
24807 case CUSTOMDATUM_CLASS:
24808 case ORADATA_CLASS:
24809 case JAVA_INTERFACE_CLASS:
24810 AttributeDeclaration();
24811 break;
24812 case PRAGMA:
24813 PragmaClause();
24814 break;
24815 default:
24816 jj_la1[346] = jj_gen;
24817 jj_consume_token(-1);
24818 throw new ParseException();
24819 }
24820 }
24821 }
24822 label_76:
24823 while (true) {
24824 switch (jj_nt.kind) {
24825 case 6:
24826 ;
24827 break;
24828 default:
24829 jj_la1[347] = jj_gen;
24830 break label_76;
24831 }
24832 jj_consume_token(6);
24833 switch (jj_nt.kind) {
24834 case CONSTRUCTOR:
24835 case FINAL:
24836 case INSTANTIABLE:
24837 case MAP:
24838 case MEMBER:
24839 case NOT:
24840 case ORDER:
24841 case OVERRIDING:
24842 case STATIC:
24843 TypeMethod();
24844 break;
24845 default:
24846 jj_la1[348] = jj_gen;
24847 if (jj_2_68(2)) {
24848 AttributeDeclaration();
24849 } else {
24850 switch (jj_nt.kind) {
24851 case PRAGMA:
24852 PragmaClause();
24853 break;
24854 default:
24855 jj_la1[349] = jj_gen;
24856 jj_consume_token(-1);
24857 throw new ParseException();
24858 }
24859 }
24860 }
24861 }
24862 jj_consume_token(7);
24863 break;
24864 default:
24865 jj_la1[350] = jj_gen;
24866 ;
24867 }
24868 label_77:
24869 while (true) {
24870 switch (jj_nt.kind) {
24871 case FINAL:
24872 case INSTANTIABLE:
24873 case NOT:
24874 case NULL:
24875 ;
24876 break;
24877 default:
24878 jj_la1[351] = jj_gen;
24879 break label_77;
24880 }
24881 switch (jj_nt.kind) {
24882 case NOT:
24883 jj_consume_token(NOT);
24884 break;
24885 default:
24886 jj_la1[352] = jj_gen;
24887 ;
24888 }
24889 switch (jj_nt.kind) {
24890 case FINAL:
24891 jj_consume_token(FINAL);
24892 break;
24893 case INSTANTIABLE:
24894 jj_consume_token(INSTANTIABLE);
24895 break;
24896 case NULL:
24897 jj_consume_token(NULL);
24898 break;
24899 default:
24900 jj_la1[353] = jj_gen;
24901 jj_consume_token(-1);
24902 throw new ParseException();
24903 }
24904 }
24905 label_78:
24906 while (true) {
24907 switch (jj_nt.kind) {
24908 case ALTER:
24909 ;
24910 break;
24911 default:
24912 jj_la1[354] = jj_gen;
24913 break label_78;
24914 }
24915 AlterTypeSpec();
24916 }
24917 switch (jj_nt.kind) {
24918 case 1:
24919 case 4:
24920 switch (jj_nt.kind) {
24921 case 4:
24922 jj_consume_token(4);
24923 break;
24924 case 1:
24925 jj_consume_token(1);
24926 break;
24927 default:
24928 jj_la1[355] = jj_gen;
24929 jj_consume_token(-1);
24930 throw new ParseException();
24931 }
24932 label_79:
24933 while (true) {
24934 switch (jj_nt.kind) {
24935 case ALTER:
24936 ;
24937 break;
24938 default:
24939 jj_la1[356] = jj_gen;
24940 break label_79;
24941 }
24942 AlterTypeSpec();
24943 switch (jj_nt.kind) {
24944 case 1:
24945 jj_consume_token(1);
24946 break;
24947 case 4:
24948 jj_consume_token(4);
24949 break;
24950 default:
24951 jj_la1[357] = jj_gen;
24952 jj_consume_token(-1);
24953 throw new ParseException();
24954 }
24955 }
24956 break;
24957 default:
24958 jj_la1[358] = jj_gen;
24959 ;
24960 }
24961 jjtree.closeNodeScope(jjtn000, true);
24962 jjtc000 = false;
24963 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
24964 } catch (Throwable jjte000) {
24965 if (jjtc000) {
24966 jjtree.clearNodeScope(jjtn000);
24967 jjtc000 = false;
24968 } else {
24969 jjtree.popNode();
24970 }
24971 if (jjte000 instanceof RuntimeException) {
24972 {if (true) throw (RuntimeException)jjte000;}
24973 }
24974 if (jjte000 instanceof ParseException) {
24975 {if (true) throw (ParseException)jjte000;}
24976 }
24977 {if (true) throw (Error)jjte000;}
24978 } finally {
24979 if (jjtc000) {
24980 jjtree.closeNodeScope(jjtn000, true);
24981 }
24982 }
24983 throw new Error("Missing return statement in function");
24984 }
24985
24986 final public ASTAlterTypeSpec AlterTypeSpec() throws ParseException {
24987
24988 ASTAlterTypeSpec jjtn000 = new ASTAlterTypeSpec(this, JJTALTERTYPESPEC);
24989 boolean jjtc000 = true;
24990 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
24991 try {
24992 jj_consume_token(ALTER);
24993 jj_consume_token(TYPE);
24994 simpleNode = QualifiedName();
24995 label_80:
24996 while (true) {
24997 switch (jj_nt.kind) {
24998 case 6:
24999 case ADD:
25000 case DROP:
25001 case MODIFY:
25002 ;
25003 break;
25004 default:
25005 jj_la1[359] = jj_gen;
25006 break label_80;
25007 }
25008 switch (jj_nt.kind) {
25009 case 6:
25010 case ADD:
25011 case MODIFY:
25012 switch (jj_nt.kind) {
25013 case 6:
25014 jj_consume_token(6);
25015 break;
25016 default:
25017 jj_la1[360] = jj_gen;
25018 ;
25019 }
25020 switch (jj_nt.kind) {
25021 case ADD:
25022 jj_consume_token(ADD);
25023 break;
25024 case MODIFY:
25025 jj_consume_token(MODIFY);
25026 break;
25027 default:
25028 jj_la1[361] = jj_gen;
25029 jj_consume_token(-1);
25030 throw new ParseException();
25031 }
25032 label_81:
25033 while (true) {
25034 switch (jj_nt.kind) {
25035 case CONSTRUCTOR:
25036 case FINAL:
25037 case INSTANTIABLE:
25038 case MAP:
25039 case MEMBER:
25040 case NOT:
25041 case ORDER:
25042 case OVERRIDING:
25043 case STATIC:
25044 TypeMethod();
25045 break;
25046 case ATTRIBUTE:
25047 jj_consume_token(ATTRIBUTE);
25048 label_82:
25049 while (true) {
25050 switch (jj_nt.kind) {
25051 case 5:
25052 ;
25053 break;
25054 default:
25055 jj_la1[362] = jj_gen;
25056 break label_82;
25057 }
25058 jj_consume_token(5);
25059 }
25060 AttributeDeclaration();
25061 label_83:
25062 while (true) {
25063 switch (jj_nt.kind) {
25064 case 6:
25065 ;
25066 break;
25067 default:
25068 jj_la1[363] = jj_gen;
25069 break label_83;
25070 }
25071 jj_consume_token(6);
25072 AttributeDeclaration();
25073 }
25074 label_84:
25075 while (true) {
25076 switch (jj_nt.kind) {
25077 case 7:
25078 ;
25079 break;
25080 default:
25081 jj_la1[364] = jj_gen;
25082 break label_84;
25083 }
25084 jj_consume_token(7);
25085 }
25086 break;
25087 case LIMIT:
25088 jj_consume_token(LIMIT);
25089 NumericLiteral();
25090 break;
25091 case ELEMENT:
25092 jj_consume_token(ELEMENT);
25093 jj_consume_token(TYPE);
25094 Datatype();
25095 break;
25096 default:
25097 jj_la1[365] = jj_gen;
25098 jj_consume_token(-1);
25099 throw new ParseException();
25100 }
25101 switch (jj_nt.kind) {
25102 case ATTRIBUTE:
25103 case CONSTRUCTOR:
25104 case ELEMENT:
25105 case FINAL:
25106 case INSTANTIABLE:
25107 case LIMIT:
25108 case MAP:
25109 case MEMBER:
25110 case NOT:
25111 case ORDER:
25112 case OVERRIDING:
25113 case STATIC:
25114 ;
25115 break;
25116 default:
25117 jj_la1[366] = jj_gen;
25118 break label_81;
25119 }
25120 }
25121 break;
25122 case DROP:
25123 jj_consume_token(DROP);
25124 label_85:
25125 while (true) {
25126 switch (jj_nt.kind) {
25127 case ATTRIBUTE:
25128 jj_consume_token(ATTRIBUTE);
25129 label_86:
25130 while (true) {
25131 switch (jj_nt.kind) {
25132 case 5:
25133 ;
25134 break;
25135 default:
25136 jj_la1[367] = jj_gen;
25137 break label_86;
25138 }
25139 jj_consume_token(5);
25140 }
25141 Attribute();
25142 label_87:
25143 while (true) {
25144 switch (jj_nt.kind) {
25145 case 6:
25146 ;
25147 break;
25148 default:
25149 jj_la1[368] = jj_gen;
25150 break label_87;
25151 }
25152 jj_consume_token(6);
25153 Attribute();
25154 }
25155 label_88:
25156 while (true) {
25157 switch (jj_nt.kind) {
25158 case 7:
25159 ;
25160 break;
25161 default:
25162 jj_la1[369] = jj_gen;
25163 break label_88;
25164 }
25165 jj_consume_token(7);
25166 }
25167 break;
25168 case CONSTRUCTOR:
25169 case FINAL:
25170 case INSTANTIABLE:
25171 case MAP:
25172 case MEMBER:
25173 case NOT:
25174 case ORDER:
25175 case OVERRIDING:
25176 case STATIC:
25177 TypeMethod();
25178 break;
25179 default:
25180 jj_la1[370] = jj_gen;
25181 jj_consume_token(-1);
25182 throw new ParseException();
25183 }
25184 switch (jj_nt.kind) {
25185 case ATTRIBUTE:
25186 case CONSTRUCTOR:
25187 case FINAL:
25188 case INSTANTIABLE:
25189 case MAP:
25190 case MEMBER:
25191 case NOT:
25192 case ORDER:
25193 case OVERRIDING:
25194 case STATIC:
25195 ;
25196 break;
25197 default:
25198 jj_la1[371] = jj_gen;
25199 break label_85;
25200 }
25201 }
25202 break;
25203 default:
25204 jj_la1[372] = jj_gen;
25205 jj_consume_token(-1);
25206 throw new ParseException();
25207 }
25208 }
25209 switch (jj_nt.kind) {
25210 case REPLACE:
25211 jj_consume_token(REPLACE);
25212 label_89:
25213 while (true) {
25214 if (jj_2_69(2)) {
25215 ;
25216 } else {
25217 break label_89;
25218 }
25219 switch (jj_nt.kind) {
25220 case AUTHID:
25221 jj_consume_token(AUTHID);
25222 switch (jj_nt.kind) {
25223 case CURRENT_USER:
25224 jj_consume_token(CURRENT_USER);
25225 break;
25226 case DEFINER:
25227 jj_consume_token(DEFINER);
25228 break;
25229 default:
25230 jj_la1[373] = jj_gen;
25231 jj_consume_token(-1);
25232 throw new ParseException();
25233 }
25234 break;
25235 case ACCESSIBLE:
25236 AccessibleByClause();
25237 break;
25238 default:
25239 jj_la1[374] = jj_gen;
25240 jj_consume_token(-1);
25241 throw new ParseException();
25242 }
25243 }
25244 switch (jj_nt.kind) {
25245 case IS:
25246 jj_consume_token(IS);
25247 break;
25248 case AS:
25249 jj_consume_token(AS);
25250 break;
25251 default:
25252 jj_la1[375] = jj_gen;
25253 jj_consume_token(-1);
25254 throw new ParseException();
25255 }
25256 jj_consume_token(OBJECT);
25257 jj_consume_token(5);
25258 if (jj_2_70(2)) {
25259 TypeMethod();
25260 } else {
25261 switch (jj_nt.kind) {
25262 case REPLACE:
25263 case DEFINER:
25264 case CURRENT_USER:
25265 case SERIALLY_REUSABLE:
25266 case RESTRICT_REFERENCES:
25267 case EXCEPTION_INIT:
25268 case AUTONOMOUS_TRANSACTION:
25269 case LANGUAGE:
25270 case ADD:
25271 case AGGREGATE:
25272 case ALL:
25273 case ALTER:
25274 case AND:
25275 case ANY:
25276 case ARRAY:
25277 case AS:
25278 case ASC:
25279 case AT:
25280 case ATTRIBUTE:
25281 case AUTHID:
25282 case AVG:
25283 case BETWEEN:
25284 case BINARY_INTEGER:
25285 case BODY:
25286 case BOOLEAN:
25287 case BULK:
25288 case BY:
25289 case BYTE:
25290 case CASCADE:
25291 case CASE:
25292 case CHAR:
25293 case CHAR_BASE:
25294 case CHECK:
25295 case CLOSE:
25296 case CLUSTER:
25297 case COALESCE:
25298 case COLLECT:
25299 case COLUMN:
25300 case COMMENT:
25301 case COMMIT:
25302 case COMPRESS:
25303 case CONNECT:
25304 case CONSTANT:
25305 case CONSTRUCTOR:
25306 case CONTINUE:
25307 case CONVERT:
25308 case CREATE:
25309 case CURRENT:
25310 case CURRVAL:
25311 case CURSOR:
25312 case DATA:
25313 case DATE:
25314 case DAY:
25315 case DECLARE:
25316 case DECIMAL:
25317 case _DEFAULT:
25318 case DELETE:
25319 case DESC:
25320 case DISABLE:
25321 case DISTINCT:
25322 case DO:
25323 case DROP:
25324 case EDITIONABLE:
25325 case ELEMENT:
25326 case ELSE:
25327 case ELSIF:
25328 case ENABLE:
25329 case ESCAPE:
25330 case EXCEPT:
25331 case EXCEPTION:
25332 case EXCEPTIONS:
25333 case EXCLUSIVE:
25334 case EXECUTE:
25335 case EXISTS:
25336 case EXIT:
25337 case EXTERNAL:
25338 case EXTENDS:
25339 case EXTRACT:
25340 case FALSE:
25341 case FETCH:
25342 case FINAL:
25343 case FLOAT:
25344 case FOR:
25345 case FORALL:
25346 case FORCE:
25347 case FROM:
25348 case FUNCTION:
25349 case GLOBAL:
25350 case GOTO:
25351 case GROUP:
25352 case HASH:
25353 case HAVING:
25354 case HEAP:
25355 case HOUR:
25356 case IF:
25357 case IMMEDIATE:
25358 case IN:
25359 case INDEX:
25360 case INDICES:
25361 case INDEXTYPE:
25362 case INDICATOR:
25363 case INSERT:
25364 case INSTANTIABLE:
25365 case INTEGER:
25366 case INTERFACE:
25367 case INTERSECT:
25368 case INTERVAL:
25369 case INTO:
25370 case INVALIDATE:
25371 case IS:
25372 case ISOLATION:
25373 case JAVA:
25374 case LEVEL:
25375 case LIKE:
25376 case LIMIT:
25377 case LIMITED:
25378 case LOCK:
25379 case LONG:
25380 case LOOP:
25381 case MAP:
25382 case MAX:
25383 case MEMBER:
25384 case MERGE:
25385 case MIN:
25386 case MINUS:
25387 case MINUTE:
25388 case MLSLABEL:
25389 case MODIFY:
25390 case MOD:
25391 case MODE:
25392 case MONTH:
25393 case NATURAL:
25394 case NATURALN:
25395 case NEW:
25396 case NEXTVAL:
25397 case NO:
25398 case NOCOPY:
25399 case NONEDITIONABLE:
25400 case NOT:
25401 case NOWAIT:
25402 case NULL:
25403 case NULLIF:
25404 case NUMBER:
25405 case BFILE_BASE:
25406 case BLOB_BASE:
25407 case CLOB_BASE:
25408 case DATE_BASE:
25409 case NUMBER_BASE:
25410 case OBJECT:
25411 case OCIROWID:
25412 case OF:
25413 case OID:
25414 case ON:
25415 case OPAQUE:
25416 case OPEN:
25417 case OPERATOR:
25418 case OPTION:
25419 case OR:
25420 case ORDER:
25421 case ORGANIZATION:
25422 case OTHERS:
25423 case OUT:
25424 case OVERRIDING:
25425 case PACKAGE:
25426 case PARTITION:
25427 case PCTFREE:
25428 case PLS_INTEGER:
25429 case POSITIVE:
25430 case POSITIVEN:
25431 case PRESERVE:
25432 case PRIOR:
25433 case PROMPT:
25434 case PRIVATE:
25435 case PROCEDURE:
25436 case PUBLIC:
25437 case RAISE:
25438 case RANGE:
25439 case RAW:
25440 case REAL:
25441 case RECORD:
25442 case REF:
25443 case RELEASE:
25444 case RELIES_ON:
25445 case RENAME:
25446 case RESULT:
25447 case RETURN:
25448 case RETURNING:
25449 case REVERSE:
25450 case ROLLBACK:
25451 case ROW:
25452 case ROWS:
25453 case ROWID:
25454 case ROWNUM:
25455 case ROWTYPE:
25456 case SAVE:
25457 case SAVEPOINT:
25458 case SECOND:
25459 case SELECT:
25460 case SELF:
25461 case SEPARATE:
25462 case SET:
25463 case SHARE:
25464 case SMALLINT:
25465 case SPACE:
25466 case SQL:
25467 case SQLCODE:
25468 case SQLERRM:
25469 case START:
25470 case STATIC:
25471 case STDDEV:
25472 case SUBTYPE:
25473 case SUBSTITUTABLE:
25474 case SUCCESSFUL:
25475 case SUM:
25476 case SYNONYM:
25477 case SYSDATE:
25478 case SYS_REFCURSOR:
25479 case TABLE:
25480 case TEMPORARY:
25481 case THEN:
25482 case TIME:
25483 case TIMESTAMP:
25484 case TIMEZONE_REGION:
25485 case TIMEZONE_ABBR:
25486 case TIMEZONE_MINUTE:
25487 case TIMEZONE_HOUR:
25488 case TO:
25489 case TRANSACTION:
25490 case TRIGGER:
25491 case TRUE:
25492 case TYPE:
25493 case UI:
25494 case UNDER:
25495 case USING:
25496 case WHILE:
25497 case YES:
25498 case SHOW:
25499 case A:
25500 case UPDATE:
25501 case VARCHAR:
25502 case VARCHAR2:
25503 case DOUBLE:
25504 case DEC:
25505 case PRECISION:
25506 case INT:
25507 case NUMERIC:
25508 case SIGNTYPE:
25509 case NCHAR:
25510 case NVARCHAR2:
25511 case STRING:
25512 case UROWID:
25513 case VARRAY:
25514 case VARYING:
25515 case BFILE:
25516 case BLOB:
25517 case CLOB:
25518 case NCLOB:
25519 case YEAR:
25520 case LOCAL:
25521 case WITH:
25522 case ZONE:
25523 case CHARACTER:
25524 case AFTER:
25525 case BEFORE:
25526 case OLD:
25527 case PARENT:
25528 case ANALYZE:
25529 case ASSOCIATE:
25530 case AUDIT:
25531 case COMPOUND:
25532 case DATABASE:
25533 case CALL:
25534 case DDL:
25535 case DISASSOCIATE:
25536 case EACH:
25537 case FOLLOWS:
25538 case LOGOFF:
25539 case LOGON:
25540 case NESTED:
25541 case NOAUDIT:
25542 case SCHEMA:
25543 case SERVERERROR:
25544 case SHUTDOWN:
25545 case STARTUP:
25546 case STATEMENT:
25547 case STATISTICS:
25548 case SUSPEND:
25549 case TRUNCATE:
25550 case WRAPPED:
25551 case LIBRARY:
25552 case NAME:
25553 case STRUCT:
25554 case CONTEXT:
25555 case PARAMETERS:
25556 case LENGTH:
25557 case TDO:
25558 case MAXLEN:
25559 case CHARSETID:
25560 case CHARSETFORM:
25561 case ACCEPT:
25562 case ACCESSIBLE:
25563 case COPY:
25564 case DEFINE:
25565 case DISCONNECT:
25566 case HOST:
25567 case PRINT:
25568 case QUIT:
25569 case REMARK:
25570 case UNDEFINE:
25571 case VARIABLE:
25572 case WHENEVER:
25573 case ATTACH:
25574 case CAST:
25575 case TREAT:
25576 case TRIM:
25577 case LEFT:
25578 case RIGHT:
25579 case BOTH:
25580 case EMPTY:
25581 case MULTISET:
25582 case SUBMULTISET:
25583 case LEADING:
25584 case TRAILING:
25585 case CHAR_CS:
25586 case NCHAR_CS:
25587 case DBTIMEZONE:
25588 case SESSIONTIMEZONE:
25589 case AUTHENTICATED:
25590 case LINK:
25591 case SHARED:
25592 case DIRECTORY:
25593 case USER:
25594 case IDENTIFIER:
25595 case QUOTED_LITERAL:
25596 case SQLDATA_CLASS:
25597 case CUSTOMDATUM_CLASS:
25598 case ORADATA_CLASS:
25599 case JAVA_INTERFACE_CLASS:
25600 AttributeDeclaration();
25601 break;
25602 default:
25603 jj_la1[376] = jj_gen;
25604 jj_consume_token(-1);
25605 throw new ParseException();
25606 }
25607 }
25608 label_90:
25609 while (true) {
25610 switch (jj_nt.kind) {
25611 case 6:
25612 ;
25613 break;
25614 default:
25615 jj_la1[377] = jj_gen;
25616 break label_90;
25617 }
25618 jj_consume_token(6);
25619 if (jj_2_71(2)) {
25620 TypeMethod();
25621 } else {
25622 switch (jj_nt.kind) {
25623 case REPLACE:
25624 case DEFINER:
25625 case CURRENT_USER:
25626 case SERIALLY_REUSABLE:
25627 case RESTRICT_REFERENCES:
25628 case EXCEPTION_INIT:
25629 case AUTONOMOUS_TRANSACTION:
25630 case LANGUAGE:
25631 case ADD:
25632 case AGGREGATE:
25633 case ALL:
25634 case ALTER:
25635 case AND:
25636 case ANY:
25637 case ARRAY:
25638 case AS:
25639 case ASC:
25640 case AT:
25641 case ATTRIBUTE:
25642 case AUTHID:
25643 case AVG:
25644 case BETWEEN:
25645 case BINARY_INTEGER:
25646 case BODY:
25647 case BOOLEAN:
25648 case BULK:
25649 case BY:
25650 case BYTE:
25651 case CASCADE:
25652 case CASE:
25653 case CHAR:
25654 case CHAR_BASE:
25655 case CHECK:
25656 case CLOSE:
25657 case CLUSTER:
25658 case COALESCE:
25659 case COLLECT:
25660 case COLUMN:
25661 case COMMENT:
25662 case COMMIT:
25663 case COMPRESS:
25664 case CONNECT:
25665 case CONSTANT:
25666 case CONSTRUCTOR:
25667 case CONTINUE:
25668 case CONVERT:
25669 case CREATE:
25670 case CURRENT:
25671 case CURRVAL:
25672 case CURSOR:
25673 case DATA:
25674 case DATE:
25675 case DAY:
25676 case DECLARE:
25677 case DECIMAL:
25678 case _DEFAULT:
25679 case DELETE:
25680 case DESC:
25681 case DISABLE:
25682 case DISTINCT:
25683 case DO:
25684 case DROP:
25685 case EDITIONABLE:
25686 case ELEMENT:
25687 case ELSE:
25688 case ELSIF:
25689 case ENABLE:
25690 case ESCAPE:
25691 case EXCEPT:
25692 case EXCEPTION:
25693 case EXCEPTIONS:
25694 case EXCLUSIVE:
25695 case EXECUTE:
25696 case EXISTS:
25697 case EXIT:
25698 case EXTERNAL:
25699 case EXTENDS:
25700 case EXTRACT:
25701 case FALSE:
25702 case FETCH:
25703 case FINAL:
25704 case FLOAT:
25705 case FOR:
25706 case FORALL:
25707 case FORCE:
25708 case FROM:
25709 case FUNCTION:
25710 case GLOBAL:
25711 case GOTO:
25712 case GROUP:
25713 case HASH:
25714 case HAVING:
25715 case HEAP:
25716 case HOUR:
25717 case IF:
25718 case IMMEDIATE:
25719 case IN:
25720 case INDEX:
25721 case INDICES:
25722 case INDEXTYPE:
25723 case INDICATOR:
25724 case INSERT:
25725 case INSTANTIABLE:
25726 case INTEGER:
25727 case INTERFACE:
25728 case INTERSECT:
25729 case INTERVAL:
25730 case INTO:
25731 case INVALIDATE:
25732 case IS:
25733 case ISOLATION:
25734 case JAVA:
25735 case LEVEL:
25736 case LIKE:
25737 case LIMIT:
25738 case LIMITED:
25739 case LOCK:
25740 case LONG:
25741 case LOOP:
25742 case MAP:
25743 case MAX:
25744 case MEMBER:
25745 case MERGE:
25746 case MIN:
25747 case MINUS:
25748 case MINUTE:
25749 case MLSLABEL:
25750 case MODIFY:
25751 case MOD:
25752 case MODE:
25753 case MONTH:
25754 case NATURAL:
25755 case NATURALN:
25756 case NEW:
25757 case NEXTVAL:
25758 case NO:
25759 case NOCOPY:
25760 case NONEDITIONABLE:
25761 case NOT:
25762 case NOWAIT:
25763 case NULL:
25764 case NULLIF:
25765 case NUMBER:
25766 case BFILE_BASE:
25767 case BLOB_BASE:
25768 case CLOB_BASE:
25769 case DATE_BASE:
25770 case NUMBER_BASE:
25771 case OBJECT:
25772 case OCIROWID:
25773 case OF:
25774 case OID:
25775 case ON:
25776 case OPAQUE:
25777 case OPEN:
25778 case OPERATOR:
25779 case OPTION:
25780 case OR:
25781 case ORDER:
25782 case ORGANIZATION:
25783 case OTHERS:
25784 case OUT:
25785 case OVERRIDING:
25786 case PACKAGE:
25787 case PARTITION:
25788 case PCTFREE:
25789 case PLS_INTEGER:
25790 case POSITIVE:
25791 case POSITIVEN:
25792 case PRESERVE:
25793 case PRIOR:
25794 case PROMPT:
25795 case PRIVATE:
25796 case PROCEDURE:
25797 case PUBLIC:
25798 case RAISE:
25799 case RANGE:
25800 case RAW:
25801 case REAL:
25802 case RECORD:
25803 case REF:
25804 case RELEASE:
25805 case RELIES_ON:
25806 case RENAME:
25807 case RESULT:
25808 case RETURN:
25809 case RETURNING:
25810 case REVERSE:
25811 case ROLLBACK:
25812 case ROW:
25813 case ROWS:
25814 case ROWID:
25815 case ROWNUM:
25816 case ROWTYPE:
25817 case SAVE:
25818 case SAVEPOINT:
25819 case SECOND:
25820 case SELECT:
25821 case SELF:
25822 case SEPARATE:
25823 case SET:
25824 case SHARE:
25825 case SMALLINT:
25826 case SPACE:
25827 case SQL:
25828 case SQLCODE:
25829 case SQLERRM:
25830 case START:
25831 case STATIC:
25832 case STDDEV:
25833 case SUBTYPE:
25834 case SUBSTITUTABLE:
25835 case SUCCESSFUL:
25836 case SUM:
25837 case SYNONYM:
25838 case SYSDATE:
25839 case SYS_REFCURSOR:
25840 case TABLE:
25841 case TEMPORARY:
25842 case THEN:
25843 case TIME:
25844 case TIMESTAMP:
25845 case TIMEZONE_REGION:
25846 case TIMEZONE_ABBR:
25847 case TIMEZONE_MINUTE:
25848 case TIMEZONE_HOUR:
25849 case TO:
25850 case TRANSACTION:
25851 case TRIGGER:
25852 case TRUE:
25853 case TYPE:
25854 case UI:
25855 case UNDER:
25856 case USING:
25857 case WHILE:
25858 case YES:
25859 case SHOW:
25860 case A:
25861 case UPDATE:
25862 case VARCHAR:
25863 case VARCHAR2:
25864 case DOUBLE:
25865 case DEC:
25866 case PRECISION:
25867 case INT:
25868 case NUMERIC:
25869 case SIGNTYPE:
25870 case NCHAR:
25871 case NVARCHAR2:
25872 case STRING:
25873 case UROWID:
25874 case VARRAY:
25875 case VARYING:
25876 case BFILE:
25877 case BLOB:
25878 case CLOB:
25879 case NCLOB:
25880 case YEAR:
25881 case LOCAL:
25882 case WITH:
25883 case ZONE:
25884 case CHARACTER:
25885 case AFTER:
25886 case BEFORE:
25887 case OLD:
25888 case PARENT:
25889 case ANALYZE:
25890 case ASSOCIATE:
25891 case AUDIT:
25892 case COMPOUND:
25893 case DATABASE:
25894 case CALL:
25895 case DDL:
25896 case DISASSOCIATE:
25897 case EACH:
25898 case FOLLOWS:
25899 case LOGOFF:
25900 case LOGON:
25901 case NESTED:
25902 case NOAUDIT:
25903 case SCHEMA:
25904 case SERVERERROR:
25905 case SHUTDOWN:
25906 case STARTUP:
25907 case STATEMENT:
25908 case STATISTICS:
25909 case SUSPEND:
25910 case TRUNCATE:
25911 case WRAPPED:
25912 case LIBRARY:
25913 case NAME:
25914 case STRUCT:
25915 case CONTEXT:
25916 case PARAMETERS:
25917 case LENGTH:
25918 case TDO:
25919 case MAXLEN:
25920 case CHARSETID:
25921 case CHARSETFORM:
25922 case ACCEPT:
25923 case ACCESSIBLE:
25924 case COPY:
25925 case DEFINE:
25926 case DISCONNECT:
25927 case HOST:
25928 case PRINT:
25929 case QUIT:
25930 case REMARK:
25931 case UNDEFINE:
25932 case VARIABLE:
25933 case WHENEVER:
25934 case ATTACH:
25935 case CAST:
25936 case TREAT:
25937 case TRIM:
25938 case LEFT:
25939 case RIGHT:
25940 case BOTH:
25941 case EMPTY:
25942 case MULTISET:
25943 case SUBMULTISET:
25944 case LEADING:
25945 case TRAILING:
25946 case CHAR_CS:
25947 case NCHAR_CS:
25948 case DBTIMEZONE:
25949 case SESSIONTIMEZONE:
25950 case AUTHENTICATED:
25951 case LINK:
25952 case SHARED:
25953 case DIRECTORY:
25954 case USER:
25955 case IDENTIFIER:
25956 case QUOTED_LITERAL:
25957 case SQLDATA_CLASS:
25958 case CUSTOMDATUM_CLASS:
25959 case ORADATA_CLASS:
25960 case JAVA_INTERFACE_CLASS:
25961 AttributeDeclaration();
25962 break;
25963 default:
25964 jj_la1[378] = jj_gen;
25965 jj_consume_token(-1);
25966 throw new ParseException();
25967 }
25968 }
25969 }
25970 jj_consume_token(7);
25971 break;
25972 default:
25973 jj_la1[379] = jj_gen;
25974 ;
25975 }
25976 label_91:
25977 while (true) {
25978 switch (jj_nt.kind) {
25979 case FINAL:
25980 case INSTANTIABLE:
25981 case NOT:
25982 case NULL:
25983 ;
25984 break;
25985 default:
25986 jj_la1[380] = jj_gen;
25987 break label_91;
25988 }
25989 switch (jj_nt.kind) {
25990 case NOT:
25991 jj_consume_token(NOT);
25992 break;
25993 default:
25994 jj_la1[381] = jj_gen;
25995 ;
25996 }
25997 switch (jj_nt.kind) {
25998 case FINAL:
25999 jj_consume_token(FINAL);
26000 break;
26001 case INSTANTIABLE:
26002 jj_consume_token(INSTANTIABLE);
26003 break;
26004 case NULL:
26005 jj_consume_token(NULL);
26006 break;
26007 default:
26008 jj_la1[382] = jj_gen;
26009 jj_consume_token(-1);
26010 throw new ParseException();
26011 }
26012 }
26013 switch (jj_nt.kind) {
26014 case CASCADE:
26015 case INVALIDATE:
26016 switch (jj_nt.kind) {
26017 case INVALIDATE:
26018 jj_consume_token(INVALIDATE);
26019 break;
26020 case CASCADE:
26021 jj_consume_token(CASCADE);
26022 label_92:
26023 while (true) {
26024 switch (jj_nt.kind) {
26025 case CONVERT:
26026 case INCLUDING:
26027 case NOT:
26028 ;
26029 break;
26030 default:
26031 jj_la1[383] = jj_gen;
26032 break label_92;
26033 }
26034 switch (jj_nt.kind) {
26035 case INCLUDING:
26036 case NOT:
26037 switch (jj_nt.kind) {
26038 case NOT:
26039 jj_consume_token(NOT);
26040 break;
26041 default:
26042 jj_la1[384] = jj_gen;
26043 ;
26044 }
26045 jj_consume_token(INCLUDING);
26046 jj_consume_token(TABLE);
26047 jj_consume_token(DATA);
26048 break;
26049 case CONVERT:
26050 jj_consume_token(CONVERT);
26051 jj_consume_token(TO);
26052 jj_consume_token(SUBSTITUTABLE);
26053 break;
26054 default:
26055 jj_la1[385] = jj_gen;
26056 jj_consume_token(-1);
26057 throw new ParseException();
26058 }
26059 }
26060 switch (jj_nt.kind) {
26061 case EXCEPTIONS:
26062 case FORCE:
26063 switch (jj_nt.kind) {
26064 case FORCE:
26065 jj_consume_token(FORCE);
26066 break;
26067 default:
26068 jj_la1[386] = jj_gen;
26069 ;
26070 }
26071 jj_consume_token(EXCEPTIONS);
26072 jj_consume_token(INTO);
26073 QualifiedName();
26074 break;
26075 default:
26076 jj_la1[387] = jj_gen;
26077 ;
26078 }
26079 break;
26080 default:
26081 jj_la1[388] = jj_gen;
26082 jj_consume_token(-1);
26083 throw new ParseException();
26084 }
26085 break;
26086 default:
26087 jj_la1[389] = jj_gen;
26088 ;
26089 }
26090 jjtree.closeNodeScope(jjtn000, true);
26091 jjtc000 = false;
26092 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26093 } catch (Throwable jjte000) {
26094 if (jjtc000) {
26095 jjtree.clearNodeScope(jjtn000);
26096 jjtc000 = false;
26097 } else {
26098 jjtree.popNode();
26099 }
26100 if (jjte000 instanceof RuntimeException) {
26101 {if (true) throw (RuntimeException)jjte000;}
26102 }
26103 if (jjte000 instanceof ParseException) {
26104 {if (true) throw (ParseException)jjte000;}
26105 }
26106 {if (true) throw (Error)jjte000;}
26107 } finally {
26108 if (jjtc000) {
26109 jjtree.closeNodeScope(jjtn000, true);
26110 }
26111 }
26112 throw new Error("Missing return statement in function");
26113 }
26114
26115
26116
26117
26118
26119
26120
26121
26122
26123
26124
26125
26126
26127
26128
26129
26130
26131
26132
26133
26134
26135
26136
26137
26138
26139
26140
26141
26142
26143 final public ASTAttributeDeclaration AttributeDeclaration() throws ParseException {
26144
26145 ASTAttributeDeclaration jjtn000 = new ASTAttributeDeclaration(this, JJTATTRIBUTEDECLARATION);
26146 boolean jjtc000 = true;
26147 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26148 try {
26149 simpleNode = ID();
26150 Datatype();
26151 jjtree.closeNodeScope(jjtn000, true);
26152 jjtc000 = false;
26153 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26154 } catch (Throwable jjte000) {
26155 if (jjtc000) {
26156 jjtree.clearNodeScope(jjtn000);
26157 jjtc000 = false;
26158 } else {
26159 jjtree.popNode();
26160 }
26161 if (jjte000 instanceof RuntimeException) {
26162 {if (true) throw (RuntimeException)jjte000;}
26163 }
26164 if (jjte000 instanceof ParseException) {
26165 {if (true) throw (ParseException)jjte000;}
26166 }
26167 {if (true) throw (Error)jjte000;}
26168 } finally {
26169 if (jjtc000) {
26170 jjtree.closeNodeScope(jjtn000, true);
26171 }
26172 }
26173 throw new Error("Missing return statement in function");
26174 }
26175
26176 final public ASTAttribute Attribute() throws ParseException {
26177
26178 ASTAttribute jjtn000 = new ASTAttribute(this, JJTATTRIBUTE);
26179 boolean jjtc000 = true;
26180 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null;
26181 try {
26182 simpleNode = ID();
26183 jjtree.closeNodeScope(jjtn000, true);
26184 jjtc000 = false;
26185 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
26186 } catch (Throwable jjte000) {
26187 if (jjtc000) {
26188 jjtree.clearNodeScope(jjtn000);
26189 jjtc000 = false;
26190 } else {
26191 jjtree.popNode();
26192 }
26193 if (jjte000 instanceof RuntimeException) {
26194 {if (true) throw (RuntimeException)jjte000;}
26195 }
26196 if (jjte000 instanceof ParseException) {
26197 {if (true) throw (ParseException)jjte000;}
26198 }
26199 {if (true) throw (Error)jjte000;}
26200 } finally {
26201 if (jjtc000) {
26202 jjtree.closeNodeScope(jjtn000, true);
26203 }
26204 }
26205 throw new Error("Missing return statement in function");
26206 }
26207
26208
26209
26210
26211 final public ASTPragmaClause PragmaClause() throws ParseException {
26212
26213 ASTPragmaClause jjtn000 = new ASTPragmaClause(this, JJTPRAGMACLAUSE);
26214 boolean jjtc000 = true;
26215 jjtree.openNodeScope(jjtn000);
26216 try {
26217 jj_consume_token(PRAGMA);
26218 switch (jj_nt.kind) {
26219 case SERIALLY_REUSABLE:
26220 jj_consume_token(SERIALLY_REUSABLE);
26221 break;
26222 case AUTONOMOUS_TRANSACTION:
26223 jj_consume_token(AUTONOMOUS_TRANSACTION);
26224 break;
26225 case RESTRICT_REFERENCES:
26226 jj_consume_token(RESTRICT_REFERENCES);
26227 jj_consume_token(5);
26228 ID();
26229 label_93:
26230 while (true) {
26231 jj_consume_token(6);
26232 switch (jj_nt.kind) {
26233 case REPLACE:
26234 case DEFINER:
26235 case CURRENT_USER:
26236 case SERIALLY_REUSABLE:
26237 case RESTRICT_REFERENCES:
26238 case EXCEPTION_INIT:
26239 case AUTONOMOUS_TRANSACTION:
26240 case LANGUAGE:
26241 case ADD:
26242 case AGGREGATE:
26243 case ALL:
26244 case ALTER:
26245 case AND:
26246 case ANY:
26247 case ARRAY:
26248 case AS:
26249 case ASC:
26250 case AT:
26251 case ATTRIBUTE:
26252 case AUTHID:
26253 case AVG:
26254 case BETWEEN:
26255 case BINARY_INTEGER:
26256 case BODY:
26257 case BOOLEAN:
26258 case BULK:
26259 case BY:
26260 case BYTE:
26261 case CASCADE:
26262 case CASE:
26263 case CHAR:
26264 case CHAR_BASE:
26265 case CHECK:
26266 case CLOSE:
26267 case CLUSTER:
26268 case COALESCE:
26269 case COLLECT:
26270 case COLUMN:
26271 case COMMENT:
26272 case COMMIT:
26273 case COMPRESS:
26274 case CONNECT:
26275 case CONSTANT:
26276 case CONSTRUCTOR:
26277 case CONTINUE:
26278 case CONVERT:
26279 case CREATE:
26280 case CURRENT:
26281 case CURRVAL:
26282 case CURSOR:
26283 case DATA:
26284 case DATE:
26285 case DAY:
26286 case DECLARE:
26287 case DECIMAL:
26288 case _DEFAULT:
26289 case DELETE:
26290 case DESC:
26291 case DISABLE:
26292 case DISTINCT:
26293 case DO:
26294 case DROP:
26295 case EDITIONABLE:
26296 case ELEMENT:
26297 case ELSE:
26298 case ELSIF:
26299 case ENABLE:
26300 case ESCAPE:
26301 case EXCEPT:
26302 case EXCEPTION:
26303 case EXCEPTIONS:
26304 case EXCLUSIVE:
26305 case EXECUTE:
26306 case EXISTS:
26307 case EXIT:
26308 case EXTERNAL:
26309 case EXTENDS:
26310 case EXTRACT:
26311 case FALSE:
26312 case FETCH:
26313 case FINAL:
26314 case FLOAT:
26315 case FOR:
26316 case FORALL:
26317 case FORCE:
26318 case FROM:
26319 case FUNCTION:
26320 case GLOBAL:
26321 case GOTO:
26322 case GROUP:
26323 case HASH:
26324 case HAVING:
26325 case HEAP:
26326 case HOUR:
26327 case IF:
26328 case IMMEDIATE:
26329 case IN:
26330 case INDEX:
26331 case INDICES:
26332 case INDEXTYPE:
26333 case INDICATOR:
26334 case INSERT:
26335 case INSTANTIABLE:
26336 case INTEGER:
26337 case INTERFACE:
26338 case INTERSECT:
26339 case INTERVAL:
26340 case INTO:
26341 case INVALIDATE:
26342 case IS:
26343 case ISOLATION:
26344 case JAVA:
26345 case LEVEL:
26346 case LIKE:
26347 case LIMIT:
26348 case LIMITED:
26349 case LOCK:
26350 case LONG:
26351 case LOOP:
26352 case MAP:
26353 case MAX:
26354 case MEMBER:
26355 case MERGE:
26356 case MIN:
26357 case MINUS:
26358 case MINUTE:
26359 case MLSLABEL:
26360 case MODIFY:
26361 case MOD:
26362 case MODE:
26363 case MONTH:
26364 case NATURAL:
26365 case NATURALN:
26366 case NEW:
26367 case NEXTVAL:
26368 case NO:
26369 case NOCOPY:
26370 case NONEDITIONABLE:
26371 case NOT:
26372 case NOWAIT:
26373 case NULL:
26374 case NULLIF:
26375 case NUMBER:
26376 case BFILE_BASE:
26377 case BLOB_BASE:
26378 case CLOB_BASE:
26379 case DATE_BASE:
26380 case NUMBER_BASE:
26381 case OBJECT:
26382 case OCIROWID:
26383 case OF:
26384 case OID:
26385 case ON:
26386 case OPAQUE:
26387 case OPEN:
26388 case OPERATOR:
26389 case OPTION:
26390 case OR:
26391 case ORDER:
26392 case ORGANIZATION:
26393 case OTHERS:
26394 case OUT:
26395 case OVERRIDING:
26396 case PACKAGE:
26397 case PARTITION:
26398 case PCTFREE:
26399 case PLS_INTEGER:
26400 case POSITIVE:
26401 case POSITIVEN:
26402 case PRESERVE:
26403 case PRIOR:
26404 case PROMPT:
26405 case PRIVATE:
26406 case PROCEDURE:
26407 case PUBLIC:
26408 case RAISE:
26409 case RANGE:
26410 case RAW:
26411 case REAL:
26412 case RECORD:
26413 case REF:
26414 case RELEASE:
26415 case RELIES_ON:
26416 case RENAME:
26417 case RESULT:
26418 case RETURN:
26419 case RETURNING:
26420 case REVERSE:
26421 case ROLLBACK:
26422 case ROW:
26423 case ROWS:
26424 case ROWID:
26425 case ROWNUM:
26426 case ROWTYPE:
26427 case SAVE:
26428 case SAVEPOINT:
26429 case SECOND:
26430 case SELECT:
26431 case SELF:
26432 case SEPARATE:
26433 case SET:
26434 case SHARE:
26435 case SMALLINT:
26436 case SPACE:
26437 case SQL:
26438 case SQLCODE:
26439 case SQLERRM:
26440 case START:
26441 case STATIC:
26442 case STDDEV:
26443 case SUBTYPE:
26444 case SUBSTITUTABLE:
26445 case SUCCESSFUL:
26446 case SUM:
26447 case SYNONYM:
26448 case SYSDATE:
26449 case SYS_REFCURSOR:
26450 case TABLE:
26451 case TEMPORARY:
26452 case THEN:
26453 case TIME:
26454 case TIMESTAMP:
26455 case TIMEZONE_REGION:
26456 case TIMEZONE_ABBR:
26457 case TIMEZONE_MINUTE:
26458 case TIMEZONE_HOUR:
26459 case TO:
26460 case TRANSACTION:
26461 case TRIGGER:
26462 case TRUE:
26463 case TYPE:
26464 case UI:
26465 case UNDER:
26466 case USING:
26467 case WHILE:
26468 case YES:
26469 case SHOW:
26470 case A:
26471 case UPDATE:
26472 case VARCHAR:
26473 case VARCHAR2:
26474 case DOUBLE:
26475 case DEC:
26476 case PRECISION:
26477 case INT:
26478 case NUMERIC:
26479 case SIGNTYPE:
26480 case NCHAR:
26481 case NVARCHAR2:
26482 case STRING:
26483 case UROWID:
26484 case VARRAY:
26485 case VARYING:
26486 case BFILE:
26487 case BLOB:
26488 case CLOB:
26489 case NCLOB:
26490 case YEAR:
26491 case LOCAL:
26492 case WITH:
26493 case ZONE:
26494 case CHARACTER:
26495 case AFTER:
26496 case BEFORE:
26497 case OLD:
26498 case PARENT:
26499 case ANALYZE:
26500 case ASSOCIATE:
26501 case AUDIT:
26502 case COMPOUND:
26503 case DATABASE:
26504 case CALL:
26505 case DDL:
26506 case DISASSOCIATE:
26507 case EACH:
26508 case FOLLOWS:
26509 case LOGOFF:
26510 case LOGON:
26511 case NESTED:
26512 case NOAUDIT:
26513 case SCHEMA:
26514 case SERVERERROR:
26515 case SHUTDOWN:
26516 case STARTUP:
26517 case STATEMENT:
26518 case STATISTICS:
26519 case SUSPEND:
26520 case TRUNCATE:
26521 case WRAPPED:
26522 case LIBRARY:
26523 case NAME:
26524 case STRUCT:
26525 case CONTEXT:
26526 case PARAMETERS:
26527 case LENGTH:
26528 case TDO:
26529 case MAXLEN:
26530 case CHARSETID:
26531 case CHARSETFORM:
26532 case ACCEPT:
26533 case ACCESSIBLE:
26534 case COPY:
26535 case DEFINE:
26536 case DISCONNECT:
26537 case HOST:
26538 case PRINT:
26539 case QUIT:
26540 case REMARK:
26541 case UNDEFINE:
26542 case VARIABLE:
26543 case WHENEVER:
26544 case ATTACH:
26545 case CAST:
26546 case TREAT:
26547 case TRIM:
26548 case LEFT:
26549 case RIGHT:
26550 case BOTH:
26551 case EMPTY:
26552 case MULTISET:
26553 case SUBMULTISET:
26554 case LEADING:
26555 case TRAILING:
26556 case CHAR_CS:
26557 case NCHAR_CS:
26558 case DBTIMEZONE:
26559 case SESSIONTIMEZONE:
26560 case AUTHENTICATED:
26561 case LINK:
26562 case SHARED:
26563 case DIRECTORY:
26564 case USER:
26565 case IDENTIFIER:
26566 case QUOTED_LITERAL:
26567 case SQLDATA_CLASS:
26568 case CUSTOMDATUM_CLASS:
26569 case ORADATA_CLASS:
26570 case JAVA_INTERFACE_CLASS:
26571 ID();
26572 break;
26573 case STRING_LITERAL:
26574 StringLiteral();
26575 break;
26576 default:
26577 jj_la1[390] = jj_gen;
26578 jj_consume_token(-1);
26579 throw new ParseException();
26580 }
26581 switch (jj_nt.kind) {
26582 case 6:
26583 ;
26584 break;
26585 default:
26586 jj_la1[391] = jj_gen;
26587 break label_93;
26588 }
26589 }
26590 jj_consume_token(7);
26591 break;
26592 case EXCEPTION_INIT:
26593 jj_consume_token(EXCEPTION_INIT);
26594 jj_consume_token(5);
26595 jj_consume_token(IDENTIFIER);
26596 jj_consume_token(6);
26597 switch (jj_nt.kind) {
26598 case 16:
26599 case 17:
26600 switch (jj_nt.kind) {
26601 case 16:
26602 jj_consume_token(16);
26603 break;
26604 case 17:
26605 jj_consume_token(17);
26606 break;
26607 default:
26608 jj_la1[392] = jj_gen;
26609 jj_consume_token(-1);
26610 throw new ParseException();
26611 }
26612 break;
26613 default:
26614 jj_la1[393] = jj_gen;
26615 ;
26616 }
26617 NumericLiteral();
26618 jj_consume_token(7);
26619 break;
26620 case INTERFACE:
26621 jj_consume_token(INTERFACE);
26622 jj_consume_token(5);
26623 jj_consume_token(IDENTIFIER);
26624 jj_consume_token(6);
26625 jj_consume_token(IDENTIFIER);
26626 jj_consume_token(6);
26627 NumericLiteral();
26628 jj_consume_token(7);
26629 break;
26630 default:
26631 jj_la1[394] = jj_gen;
26632 jj_consume_token(-1);
26633 throw new ParseException();
26634 }
26635 jjtree.closeNodeScope(jjtn000, true);
26636 jjtc000 = false;
26637 {if (true) return jjtn000 ;}
26638 } catch (Throwable jjte000) {
26639 if (jjtc000) {
26640 jjtree.clearNodeScope(jjtn000);
26641 jjtc000 = false;
26642 } else {
26643 jjtree.popNode();
26644 }
26645 if (jjte000 instanceof RuntimeException) {
26646 {if (true) throw (RuntimeException)jjte000;}
26647 }
26648 if (jjte000 instanceof ParseException) {
26649 {if (true) throw (ParseException)jjte000;}
26650 }
26651 {if (true) throw (Error)jjte000;}
26652 } finally {
26653 if (jjtc000) {
26654 jjtree.closeNodeScope(jjtn000, true);
26655 }
26656 }
26657 throw new Error("Missing return statement in function");
26658 }
26659
26660
26661
26662
26663
26664
26665
26666
26667
26668
26669
26670
26671
26672
26673
26674
26675
26676
26677
26678
26679
26680
26681
26682
26683
26684
26685
26686
26687
26688
26689
26690
26691
26692
26693
26694
26695
26696
26697
26698
26699
26700
26701
26702
26703
26704
26705
26706
26707
26708
26709
26710
26711
26712
26713
26714
26715
26716
26717
26718
26719
26720
26721
26722
26723
26724
26725
26726
26727
26728
26729
26730
26731
26732
26733
26734 final public ASTTriggerUnit TriggerUnit() throws ParseException {
26735
26736 ASTTriggerUnit jjtn000 = new ASTTriggerUnit(this, JJTTRIGGERUNIT);
26737 boolean jjtc000 = true;
26738 jjtree.openNodeScope(jjtn000);PLSQLNode simpleNode = null ;
26739 try {
26740 switch (jj_nt.kind) {
26741 case CREATE:
26742 jj_consume_token(CREATE);
26743 switch (jj_nt.kind) {
26744 case OR:
26745 jj_consume_token(OR);
26746 jj_consume_token(REPLACE);
26747 break;
26748 default:
26749 jj_la1[395] = jj_gen;
26750 ;
26751 }
26752 switch (jj_nt.kind) {
26753 case EDITIONABLE:
26754 case NONEDITIONABLE:
26755 switch (jj_nt.kind) {
26756 case EDITIONABLE:
26757 jj_consume_token(EDITIONABLE);
26758 break;
26759 case NONEDITIONABLE:
26760 jj_consume_token(NONEDITIONABLE);
26761 break;
26762 default:
26763 jj_la1[396] = jj_gen;
26764 jj_consume_token(-1);
26765 throw new ParseException();
26766 }
26767 break;
26768 default:
26769 jj_la1[397] = jj_gen;
26770 ;
26771 }
26772 break;
26773 default:
26774 jj_la1[398] = jj_gen;
26775 ;
26776 }
26777 jj_consume_token(TRIGGER);
26778 simpleNode = ObjectNameDeclaration();
26779 switch (jj_nt.kind) {
26780 case BEFORE:
26781 jj_consume_token(BEFORE);
26782 break;
26783 case AFTER:
26784 jj_consume_token(AFTER);
26785 break;
26786 case INSTEADOF:
26787 jj_consume_token(INSTEADOF);
26788 break;
26789 case FOR:
26790 jj_consume_token(FOR);
26791 break;
26792 default:
26793 jj_la1[399] = jj_gen;
26794 jj_consume_token(-1);
26795 throw new ParseException();
26796 }
26797 switch (jj_nt.kind) {
26798 case DELETE:
26799 case INSERT:
26800 case UPDATE:
26801 switch (jj_nt.kind) {
26802 case DELETE:
26803 jj_consume_token(DELETE);
26804 break;
26805 case INSERT:
26806 jj_consume_token(INSERT);
26807 break;
26808 case UPDATE:
26809 jj_consume_token(UPDATE);
26810 break;
26811 default:
26812 jj_la1[400] = jj_gen;
26813 jj_consume_token(-1);
26814 throw new ParseException();
26815 }
26816 if (jj_2_72(6)) {
26817 jj_consume_token(OF);
26818 ID();
26819 label_94:
26820 while (true) {
26821 switch (jj_nt.kind) {
26822 case 6:
26823 ;
26824 break;
26825 default:
26826 jj_la1[401] = jj_gen;
26827 break label_94;
26828 }
26829 jj_consume_token(6);
26830 ID();
26831 }
26832 } else {
26833 ;
26834 }
26835 break;
26836 case ALTER:
26837 case COMMENT:
26838 case CREATE:
26839 case DROP:
26840 case GRANT:
26841 case RENAME:
26842 case REVOKE:
26843 case ANALYZE:
26844 case ASSOCIATE:
26845 case AUDIT:
26846 case DDL:
26847 case DISASSOCIATE:
26848 case LOGOFF:
26849 case LOGON:
26850 case NOAUDIT:
26851 case SERVERERROR:
26852 case SHUTDOWN:
26853 case STARTUP:
26854 case SUSPEND:
26855 case TRUNCATE:
26856 NonDMLEvent();
26857 break;
26858 default:
26859 jj_la1[402] = jj_gen;
26860 jj_consume_token(-1);
26861 throw new ParseException();
26862 }
26863 label_95:
26864 while (true) {
26865 switch (jj_nt.kind) {
26866 case OR:
26867 ;
26868 break;
26869 default:
26870 jj_la1[403] = jj_gen;
26871 break label_95;
26872 }
26873 jj_consume_token(OR);
26874 switch (jj_nt.kind) {
26875 case DELETE:
26876 case INSERT:
26877 case UPDATE:
26878 switch (jj_nt.kind) {
26879 case DELETE:
26880 jj_consume_token(DELETE);
26881 break;
26882 case INSERT:
26883 jj_consume_token(INSERT);
26884 break;
26885 case UPDATE:
26886 jj_consume_token(UPDATE);
26887 break;
26888 default:
26889 jj_la1[404] = jj_gen;
26890 jj_consume_token(-1);
26891 throw new ParseException();
26892 }
26893 if (jj_2_73(6)) {
26894 jj_consume_token(OF);
26895 ID();
26896 label_96:
26897 while (true) {
26898 switch (jj_nt.kind) {
26899 case 6:
26900 ;
26901 break;
26902 default:
26903 jj_la1[405] = jj_gen;
26904 break label_96;
26905 }
26906 jj_consume_token(6);
26907 ID();
26908 }
26909 } else {
26910 ;
26911 }
26912 break;
26913 case ALTER:
26914 case COMMENT:
26915 case CREATE:
26916 case DROP:
26917 case GRANT:
26918 case RENAME:
26919 case REVOKE:
26920 case ANALYZE:
26921 case ASSOCIATE:
26922 case AUDIT:
26923 case DDL:
26924 case DISASSOCIATE:
26925 case LOGOFF:
26926 case LOGON:
26927 case NOAUDIT:
26928 case SERVERERROR:
26929 case SHUTDOWN:
26930 case STARTUP:
26931 case SUSPEND:
26932 case TRUNCATE:
26933 NonDMLEvent();
26934 break;
26935 default:
26936 jj_la1[406] = jj_gen;
26937 jj_consume_token(-1);
26938 throw new ParseException();
26939 }
26940 }
26941 jj_consume_token(ON);
26942 switch (jj_nt.kind) {
26943 case DATABASE:
26944 jj_consume_token(DATABASE);
26945 break;
26946 default:
26947 jj_la1[407] = jj_gen;
26948 if (jj_2_76(2)) {
26949 jj_consume_token(NESTED);
26950 jj_consume_token(TABLE);
26951 ID();
26952 jj_consume_token(OF);
26953 if (jj_2_74(2)) {
26954 ID();
26955 jj_consume_token(3);
26956 } else {
26957 ;
26958 }
26959 ID();
26960 } else {
26961 switch (jj_nt.kind) {
26962 case REPLACE:
26963 case DEFINER:
26964 case CURRENT_USER:
26965 case SERIALLY_REUSABLE:
26966 case RESTRICT_REFERENCES:
26967 case EXCEPTION_INIT:
26968 case AUTONOMOUS_TRANSACTION:
26969 case LANGUAGE:
26970 case ADD:
26971 case AGGREGATE:
26972 case ALL:
26973 case ALTER:
26974 case AND:
26975 case ANY:
26976 case ARRAY:
26977 case AS:
26978 case ASC:
26979 case AT:
26980 case ATTRIBUTE:
26981 case AUTHID:
26982 case AVG:
26983 case BETWEEN:
26984 case BINARY_INTEGER:
26985 case BODY:
26986 case BOOLEAN:
26987 case BULK:
26988 case BY:
26989 case BYTE:
26990 case CASCADE:
26991 case CASE:
26992 case CHAR:
26993 case CHAR_BASE:
26994 case CHECK:
26995 case CLOSE:
26996 case CLUSTER:
26997 case COALESCE:
26998 case COLLECT:
26999 case COLUMN:
27000 case COMMENT:
27001 case COMMIT:
27002 case COMPRESS:
27003 case CONNECT:
27004 case CONSTANT:
27005 case CONSTRUCTOR:
27006 case CONTINUE:
27007 case CONVERT:
27008 case CREATE:
27009 case CURRENT:
27010 case CURRVAL:
27011 case CURSOR:
27012 case DATA:
27013 case DATE:
27014 case DAY:
27015 case DECLARE:
27016 case DECIMAL:
27017 case _DEFAULT:
27018 case DELETE:
27019 case DESC:
27020 case DISABLE:
27021 case DISTINCT:
27022 case DO:
27023 case DROP:
27024 case EDITIONABLE:
27025 case ELEMENT:
27026 case ELSE:
27027 case ELSIF:
27028 case ENABLE:
27029 case ESCAPE:
27030 case EXCEPT:
27031 case EXCEPTION:
27032 case EXCEPTIONS:
27033 case EXCLUSIVE:
27034 case EXECUTE:
27035 case EXISTS:
27036 case EXIT:
27037 case EXTERNAL:
27038 case EXTENDS:
27039 case EXTRACT:
27040 case FALSE:
27041 case FETCH:
27042 case FINAL:
27043 case FLOAT:
27044 case FOR:
27045 case FORALL:
27046 case FORCE:
27047 case FROM:
27048 case FUNCTION:
27049 case GLOBAL:
27050 case GOTO:
27051 case GROUP:
27052 case HASH:
27053 case HAVING:
27054 case HEAP:
27055 case HOUR:
27056 case IF:
27057 case IMMEDIATE:
27058 case IN:
27059 case INDEX:
27060 case INDICES:
27061 case INDEXTYPE:
27062 case INDICATOR:
27063 case INSERT:
27064 case INSTANTIABLE:
27065 case INTEGER:
27066 case INTERFACE:
27067 case INTERSECT:
27068 case INTERVAL:
27069 case INTO:
27070 case INVALIDATE:
27071 case IS:
27072 case ISOLATION:
27073 case JAVA:
27074 case LEVEL:
27075 case LIKE:
27076 case LIMIT:
27077 case LIMITED:
27078 case LOCK:
27079 case LONG:
27080 case LOOP:
27081 case MAP:
27082 case MAX:
27083 case MEMBER:
27084 case MERGE:
27085 case MIN:
27086 case MINUS:
27087 case MINUTE:
27088 case MLSLABEL:
27089 case MODIFY:
27090 case MOD:
27091 case MODE:
27092 case MONTH:
27093 case NATURAL:
27094 case NATURALN:
27095 case NEW:
27096 case NEXTVAL:
27097 case NO:
27098 case NOCOPY:
27099 case NONEDITIONABLE:
27100 case NOT:
27101 case NOWAIT:
27102 case NULL:
27103 case NULLIF:
27104 case NUMBER:
27105 case BFILE_BASE:
27106 case BLOB_BASE:
27107 case CLOB_BASE:
27108 case DATE_BASE:
27109 case NUMBER_BASE:
27110 case OBJECT:
27111 case OCIROWID:
27112 case OF:
27113 case OID:
27114 case ON:
27115 case OPAQUE:
27116 case OPEN:
27117 case OPERATOR:
27118 case OPTION:
27119 case OR:
27120 case ORDER:
27121 case ORGANIZATION:
27122 case OTHERS:
27123 case OUT:
27124 case OVERRIDING:
27125 case PACKAGE:
27126 case PARTITION:
27127 case PCTFREE:
27128 case PLS_INTEGER:
27129 case POSITIVE:
27130 case POSITIVEN:
27131 case PRESERVE:
27132 case PRIOR:
27133 case PROMPT:
27134 case PRIVATE:
27135 case PROCEDURE:
27136 case PUBLIC:
27137 case RAISE:
27138 case RANGE:
27139 case RAW:
27140 case REAL:
27141 case RECORD:
27142 case REF:
27143 case RELEASE:
27144 case RELIES_ON:
27145 case RENAME:
27146 case RESULT:
27147 case RETURN:
27148 case RETURNING:
27149 case REVERSE:
27150 case ROLLBACK:
27151 case ROW:
27152 case ROWS:
27153 case ROWID:
27154 case ROWNUM:
27155 case ROWTYPE:
27156 case SAVE:
27157 case SAVEPOINT:
27158 case SECOND:
27159 case SELECT:
27160 case SELF:
27161 case SEPARATE:
27162 case SET:
27163 case SHARE:
27164 case SMALLINT:
27165 case SPACE:
27166 case SQL:
27167 case SQLCODE:
27168 case SQLERRM:
27169 case START:
27170 case STATIC:
27171 case STDDEV:
27172 case SUBTYPE:
27173 case SUBSTITUTABLE:
27174 case SUCCESSFUL:
27175 case SUM:
27176 case SYNONYM:
27177 case SYSDATE:
27178 case SYS_REFCURSOR:
27179 case TABLE:
27180 case TEMPORARY:
27181 case THEN:
27182 case TIME:
27183 case TIMESTAMP:
27184 case TIMEZONE_REGION:
27185 case TIMEZONE_ABBR:
27186 case TIMEZONE_MINUTE:
27187 case TIMEZONE_HOUR:
27188 case TO:
27189 case TRANSACTION:
27190 case TRIGGER:
27191 case TRUE:
27192 case TYPE:
27193 case UI:
27194 case UNDER:
27195 case USING:
27196 case WHILE:
27197 case YES:
27198 case SHOW:
27199 case A:
27200 case UPDATE:
27201 case VARCHAR:
27202 case VARCHAR2:
27203 case DOUBLE:
27204 case DEC:
27205 case PRECISION:
27206 case INT:
27207 case NUMERIC:
27208 case SIGNTYPE:
27209 case NCHAR:
27210 case NVARCHAR2:
27211 case STRING:
27212 case UROWID:
27213 case VARRAY:
27214 case VARYING:
27215 case BFILE:
27216 case BLOB:
27217 case CLOB:
27218 case NCLOB:
27219 case YEAR:
27220 case LOCAL:
27221 case WITH:
27222 case ZONE:
27223 case CHARACTER:
27224 case AFTER:
27225 case BEFORE:
27226 case OLD:
27227 case PARENT:
27228 case ANALYZE:
27229 case ASSOCIATE:
27230 case AUDIT:
27231 case COMPOUND:
27232 case DATABASE:
27233 case CALL:
27234 case DDL:
27235 case DISASSOCIATE:
27236 case EACH:
27237 case FOLLOWS:
27238 case LOGOFF:
27239 case LOGON:
27240 case NESTED:
27241 case NOAUDIT:
27242 case SCHEMA:
27243 case SERVERERROR:
27244 case SHUTDOWN:
27245 case STARTUP:
27246 case STATEMENT:
27247 case STATISTICS:
27248 case SUSPEND:
27249 case TRUNCATE:
27250 case WRAPPED:
27251 case LIBRARY:
27252 case NAME:
27253 case STRUCT:
27254 case CONTEXT:
27255 case PARAMETERS:
27256 case LENGTH:
27257 case TDO:
27258 case MAXLEN:
27259 case CHARSETID:
27260 case CHARSETFORM:
27261 case ACCEPT:
27262 case ACCESSIBLE:
27263 case COPY:
27264 case DEFINE:
27265 case DISCONNECT:
27266 case HOST:
27267 case PRINT:
27268 case QUIT:
27269 case REMARK:
27270 case UNDEFINE:
27271 case VARIABLE:
27272 case WHENEVER:
27273 case ATTACH:
27274 case CAST:
27275 case TREAT:
27276 case TRIM:
27277 case LEFT:
27278 case RIGHT:
27279 case BOTH:
27280 case EMPTY:
27281 case MULTISET:
27282 case SUBMULTISET:
27283 case LEADING:
27284 case TRAILING:
27285 case CHAR_CS:
27286 case NCHAR_CS:
27287 case DBTIMEZONE:
27288 case SESSIONTIMEZONE:
27289 case AUTHENTICATED:
27290 case LINK:
27291 case SHARED:
27292 case DIRECTORY:
27293 case USER:
27294 case IDENTIFIER:
27295 case QUOTED_LITERAL:
27296 case SQLDATA_CLASS:
27297 case CUSTOMDATUM_CLASS:
27298 case ORADATA_CLASS:
27299 case JAVA_INTERFACE_CLASS:
27300 if (jj_2_75(2)) {
27301 ID();
27302 jj_consume_token(3);
27303 } else {
27304 ;
27305 }
27306 ID();
27307 break;
27308 default:
27309 jj_la1[408] = jj_gen;
27310 jj_consume_token(-1);
27311 throw new ParseException();
27312 }
27313 }
27314 }
27315 switch (jj_nt.kind) {
27316 case REFERENCING:
27317 jj_consume_token(REFERENCING);
27318 label_97:
27319 while (true) {
27320 switch (jj_nt.kind) {
27321 case NEW:
27322 case OLD:
27323 case PARENT:
27324 ;
27325 break;
27326 default:
27327 jj_la1[409] = jj_gen;
27328 break label_97;
27329 }
27330 switch (jj_nt.kind) {
27331 case OLD:
27332 jj_consume_token(OLD);
27333 break;
27334 case NEW:
27335 jj_consume_token(NEW);
27336 break;
27337 case PARENT:
27338 jj_consume_token(PARENT);
27339 break;
27340 default:
27341 jj_la1[410] = jj_gen;
27342 jj_consume_token(-1);
27343 throw new ParseException();
27344 }
27345 jj_consume_token(AS);
27346 ID();
27347 }
27348 break;
27349 default:
27350 jj_la1[411] = jj_gen;
27351 ;
27352 }
27353 switch (jj_nt.kind) {
27354 case FOREACHROW:
27355 jj_consume_token(FOREACHROW);
27356 break;
27357 default:
27358 jj_la1[412] = jj_gen;
27359 ;
27360 }
27361 switch (jj_nt.kind) {
27362 case REVERSE:
27363 case FORWARD:
27364 case CROSSEDITION:
27365 switch (jj_nt.kind) {
27366 case REVERSE:
27367 case FORWARD:
27368 switch (jj_nt.kind) {
27369 case FORWARD:
27370 jj_consume_token(FORWARD);
27371 break;
27372 case REVERSE:
27373 jj_consume_token(REVERSE);
27374 break;
27375 default:
27376 jj_la1[413] = jj_gen;
27377 jj_consume_token(-1);
27378 throw new ParseException();
27379 }
27380 break;
27381 default:
27382 jj_la1[414] = jj_gen;
27383 ;
27384 }
27385 jj_consume_token(CROSSEDITION);
27386 break;
27387 default:
27388 jj_la1[415] = jj_gen;
27389 ;
27390 }
27391 switch (jj_nt.kind) {
27392 case FOLLOWS:
27393 case PRECEDES:
27394 switch (jj_nt.kind) {
27395 case FOLLOWS:
27396 jj_consume_token(FOLLOWS);
27397 break;
27398 case PRECEDES:
27399 jj_consume_token(PRECEDES);
27400 break;
27401 default:
27402 jj_la1[416] = jj_gen;
27403 jj_consume_token(-1);
27404 throw new ParseException();
27405 }
27406 if (jj_2_77(2)) {
27407 ID();
27408 jj_consume_token(3);
27409 } else {
27410 ;
27411 }
27412 ID();
27413 label_98:
27414 while (true) {
27415 switch (jj_nt.kind) {
27416 case 6:
27417 ;
27418 break;
27419 default:
27420 jj_la1[417] = jj_gen;
27421 break label_98;
27422 }
27423 jj_consume_token(6);
27424 if (jj_2_78(2)) {
27425 ID();
27426 jj_consume_token(3);
27427 } else {
27428 ;
27429 }
27430 ID();
27431 }
27432 break;
27433 default:
27434 jj_la1[418] = jj_gen;
27435 ;
27436 }
27437 switch (jj_nt.kind) {
27438 case DISABLE:
27439 case ENABLE:
27440 switch (jj_nt.kind) {
27441 case ENABLE:
27442 jj_consume_token(ENABLE);
27443 break;
27444 case DISABLE:
27445 jj_consume_token(DISABLE);
27446 break;
27447 default:
27448 jj_la1[419] = jj_gen;
27449 jj_consume_token(-1);
27450 throw new ParseException();
27451 }
27452 break;
27453 default:
27454 jj_la1[420] = jj_gen;
27455 ;
27456 }
27457 switch (jj_nt.kind) {
27458 case WHEN:
27459 jj_consume_token(WHEN);
27460 jj_consume_token(5);
27461 ConditionalOrExpression();
27462 jj_consume_token(7);
27463 break;
27464 default:
27465 jj_la1[421] = jj_gen;
27466 ;
27467 }
27468 switch (jj_nt.kind) {
27469 case CALL:
27470 jj_consume_token(CALL);
27471 PrimaryExpression();
27472 jj_consume_token(4);
27473 break;
27474 case COMPOUND:
27475 CompoundTriggerBlock();
27476 break;
27477 case BEGIN:
27478 case DECLARE:
27479 Block();
27480 jj_consume_token(4);
27481 break;
27482 default:
27483 jj_la1[422] = jj_gen;
27484 jj_consume_token(-1);
27485 throw new ParseException();
27486 }
27487 jjtree.closeNodeScope(jjtn000, true);
27488 jjtc000 = false;
27489 jjtn000.setImage(simpleNode.getImage()) ; {if (true) return jjtn000 ;}
27490 } catch (Throwable jjte000) {
27491 if (jjtc000) {
27492 jjtree.clearNodeScope(jjtn000);
27493 jjtc000 = false;
27494 } else {
27495 jjtree.popNode();
27496 }
27497 if (jjte000 instanceof RuntimeException) {
27498 {if (true) throw (RuntimeException)jjte000;}
27499 }
27500 if (jjte000 instanceof ParseException) {
27501 {if (true) throw (ParseException)jjte000;}
27502 }
27503 {if (true) throw (Error)jjte000;}
27504 } finally {
27505 if (jjtc000) {
27506 jjtree.closeNodeScope(jjtn000, true);
27507 }
27508 }
27509 throw new Error("Missing return statement in function");
27510 }
27511
27512 final public ASTTriggerTimingPointSection TriggerTimingPointSection() throws ParseException {
27513
27514 ASTTriggerTimingPointSection jjtn000 = new ASTTriggerTimingPointSection(this, JJTTRIGGERTIMINGPOINTSECTION);
27515 boolean jjtc000 = true;
27516 jjtree.openNodeScope(jjtn000);StringBuilder sb = new StringBuilder();
27517 try {
27518 switch (jj_nt.kind) {
27519 case BEFORE:
27520 jj_consume_token(BEFORE);
27521 break;
27522 case AFTER:
27523 jj_consume_token(AFTER);
27524 break;
27525 case INSTEADOF:
27526 jj_consume_token(INSTEADOF);
27527 break;
27528 default:
27529 jj_la1[423] = jj_gen;
27530 jj_consume_token(-1);
27531 throw new ParseException();
27532 }
27533 sb.append(token.image) ;
27534 switch (jj_nt.kind) {
27535 case STATEMENT:
27536 jj_consume_token(STATEMENT);
27537 break;
27538 case EACH:
27539 jj_consume_token(EACH);
27540 jj_consume_token(ROW);
27541 break;
27542 default:
27543 jj_la1[424] = jj_gen;
27544 jj_consume_token(-1);
27545 throw new ParseException();
27546 }
27547 sb.append(" "); sb.append(token.image) ;
27548 jj_consume_token(IS);
27549 jj_consume_token(BEGIN);
27550 label_99:
27551 while (true) {
27552 Statement();
27553 switch (jj_nt.kind) {
27554 case 5:
27555 case 16:
27556 case 17:
27557 case 21:
27558 case REPLACE:
27559 case DEFINER:
27560 case CURRENT_USER:
27561 case LANGUAGE:
27562 case ADD:
27563 case AGGREGATE:
27564 case ARRAY:
27565 case AT:
27566 case ATTRIBUTE:
27567 case AUTHID:
27568 case BEGIN:
27569 case BODY:
27570 case BULK:
27571 case BYTE:
27572 case CASCADE:
27573 case CASE:
27574 case CLOSE:
27575 case COALESCE:
27576 case COLLECT:
27577 case COLUMN:
27578 case COMMENT:
27579 case COMMIT:
27580 case CONSTRUCTOR:
27581 case CONTINUE:
27582 case CONVERT:
27583 case CURRENT:
27584 case CURSOR:
27585 case DATA:
27586 case DATE:
27587 case DAY:
27588 case DECLARE:
27589 case DELETE:
27590 case DISABLE:
27591 case EDITIONABLE:
27592 case ELEMENT:
27593 case ENABLE:
27594 case ESCAPE:
27595 case EXCEPT:
27596 case EXCEPTIONS:
27597 case EXECUTE:
27598 case EXIT:
27599 case EXTERNAL:
27600 case EXTENDS:
27601 case EXTRACT:
27602 case FALSE:
27603 case FETCH:
27604 case FINAL:
27605 case FOR:
27606 case FORALL:
27607 case FORCE:
27608 case FUNCTION:
27609 case GLOBAL:
27610 case GOTO:
27611 case HASH:
27612 case HEAP:
27613 case HOUR:
27614 case IF:
27615 case IMMEDIATE:
27616 case INDICES:
27617 case INDEXTYPE:
27618 case INDICATOR:
27619 case INSERT:
27620 case INSTANTIABLE:
27621 case INTERVAL:
27622 case INVALIDATE:
27623 case ISOLATION:
27624 case JAVA:
27625 case LEVEL:
27626 case LIMIT:
27627 case LOCK:
27628 case LOOP:
27629 case MAP:
27630 case MAX:
27631 case MEMBER:
27632 case MERGE:
27633 case MIN:
27634 case MINUTE:
27635 case MLSLABEL:
27636 case MODIFY:
27637 case MOD:
27638 case MONTH:
27639 case NATURAL:
27640 case NEW:
27641 case NEW_DOT:
27642 case NO:
27643 case NONEDITIONABLE:
27644 case NOT:
27645 case NULL:
27646 case NULLIF:
27647 case OBJECT:
27648 case OID:
27649 case OPAQUE:
27650 case OPEN:
27651 case OPERATOR:
27652 case ORGANIZATION:
27653 case OTHERS:
27654 case OVERRIDING:
27655 case PACKAGE:
27656 case PARTITION:
27657 case PIPE:
27658 case PRESERVE:
27659 case PRIVATE:
27660 case PROCEDURE:
27661 case RAISE:
27662 case RANGE:
27663 case RAW:
27664 case REAL:
27665 case RECORD:
27666 case REF:
27667 case RELEASE:
27668 case RELIES_ON:
27669 case RENAME:
27670 case RESULT:
27671 case RETURN:
27672 case RETURNING:
27673 case REVERSE:
27674 case ROLLBACK:
27675 case ROW:
27676 case ROWS:
27677 case ROWID:
27678 case ROWNUM:
27679 case SAVE:
27680 case SAVEPOINT:
27681 case SECOND:
27682 case SELECT:
27683 case SELF:
27684 case SET:
27685 case SPACE:
27686 case SQL:
27687 case SQLCODE:
27688 case SQLERRM:
27689 case STATIC:
27690 case SUBTYPE:
27691 case SUBSTITUTABLE:
27692 case SUCCESSFUL:
27693 case SYSDATE:
27694 case SYS_REFCURSOR:
27695 case TEMPORARY:
27696 case TIME:
27697 case TIMESTAMP:
27698 case TIMEZONE_REGION:
27699 case TIMEZONE_ABBR:
27700 case TIMEZONE_MINUTE:
27701 case TIMEZONE_HOUR:
27702 case TRANSACTION:
27703 case TRUE:
27704 case TYPE:
27705 case UNDER:
27706 case USING:
27707 case WHILE:
27708 case YES:
27709 case SHOW:
27710 case A:
27711 case UPDATE:
27712 case DOUBLE:
27713 case DEC:
27714 case PRECISION:
27715 case INT:
27716 case NUMERIC:
27717 case NCHAR:
27718 case NVARCHAR2:
27719 case STRING:
27720 case UROWID:
27721 case VARRAY:
27722 case VARYING:
27723 case BFILE:
27724 case BLOB:
27725 case CLOB:
27726 case NCLOB:
27727 case YEAR:
27728 case LOCAL:
27729 case WITH:
27730 case ZONE:
27731 case CHARACTER:
27732 case AFTER:
27733 case BEFORE:
27734 case OLD:
27735 case PARENT:
27736 case CC_IF:
27737 case CC_ERROR:
27738 case ANALYZE:
27739 case ASSOCIATE:
27740 case AUDIT:
27741 case COMPOUND:
27742 case DATABASE:
27743 case CALL:
27744 case DDL:
27745 case DISASSOCIATE:
27746 case EACH:
27747 case FOLLOWS:
27748 case LOGOFF:
27749 case LOGON:
27750 case NESTED:
27751 case NOAUDIT:
27752 case SCHEMA:
27753 case SERVERERROR:
27754 case SHUTDOWN:
27755 case STARTUP:
27756 case STATEMENT:
27757 case STATISTICS:
27758 case SUSPEND:
27759 case TRUNCATE:
27760 case WRAPPED:
27761 case LIBRARY:
27762 case NAME:
27763 case STRUCT:
27764 case CONTEXT:
27765 case PARAMETERS:
27766 case LENGTH:
27767 case TDO:
27768 case MAXLEN:
27769 case CHARSETID:
27770 case CHARSETFORM:
27771 case ACCEPT:
27772 case ACCESSIBLE:
27773 case COPY:
27774 case DEFINE:
27775 case DISCONNECT:
27776 case HOST:
27777 case PRINT:
27778 case QUIT:
27779 case REMARK:
27780 case UNDEFINE:
27781 case VARIABLE:
27782 case WHENEVER:
27783 case ATTACH:
27784 case CAST:
27785 case TREAT:
27786 case TRIM:
27787 case LEFT:
27788 case RIGHT:
27789 case BOTH:
27790 case EMPTY:
27791 case MULTISET:
27792 case SUBMULTISET:
27793 case LEADING:
27794 case TRAILING:
27795 case CHAR_CS:
27796 case NCHAR_CS:
27797 case DBTIMEZONE:
27798 case SESSIONTIMEZONE:
27799 case AUTHENTICATED:
27800 case LINK:
27801 case SHARED:
27802 case DIRECTORY:
27803 case USER:
27804 case IDENTIFIER:
27805 case UNSIGNED_NUMERIC_LITERAL:
27806 case CHARACTER_LITERAL:
27807 case STRING_LITERAL:
27808 case QUOTED_LITERAL:
27809 ;
27810 break;
27811 default:
27812 jj_la1[425] = jj_gen;
27813 break label_99;
27814 }
27815 }
27816 jj_consume_token(END);
27817 switch (jj_nt.kind) {
27818 case BEFORE:
27819 jj_consume_token(BEFORE);
27820 break;
27821 case AFTER:
27822 jj_consume_token(AFTER);
27823 break;
27824 case INSTEADOF:
27825 jj_consume_token(INSTEADOF);
27826 break;
27827 default:
27828 jj_la1[426] = jj_gen;
27829 jj_consume_token(-1);
27830 throw new ParseException();
27831 }
27832 switch (jj_nt.kind) {
27833 case STATEMENT:
27834 jj_consume_token(STATEMENT);
27835 break;
27836 case EACH:
27837 jj_consume_token(EACH);
27838 jj_consume_token(ROW);
27839 break;
27840 default:
27841 jj_la1[427] = jj_gen;
27842 jj_consume_token(-1);
27843 throw new ParseException();
27844 }
27845 jj_consume_token(4);
27846
27847 jjtree.closeNodeScope(jjtn000, true);
27848 jjtc000 = false;
27849 jjtn000.setImage(sb.toString()) ; {if (true) return jjtn000 ;}
27850 } catch (Throwable jjte000) {
27851 if (jjtc000) {
27852 jjtree.clearNodeScope(jjtn000);
27853 jjtc000 = false;
27854 } else {
27855 jjtree.popNode();
27856 }
27857 if (jjte000 instanceof RuntimeException) {
27858 {if (true) throw (RuntimeException)jjte000;}
27859 }
27860 if (jjte000 instanceof ParseException) {
27861 {if (true) throw (ParseException)jjte000;}
27862 }
27863 {if (true) throw (Error)jjte000;}
27864 } finally {
27865 if (jjtc000) {
27866 jjtree.closeNodeScope(jjtn000, true);
27867 }
27868 }
27869 throw new Error("Missing return statement in function");
27870 }
27871
27872 final public ASTCompoundTriggerBlock CompoundTriggerBlock() throws ParseException {
27873
27874 ASTCompoundTriggerBlock jjtn000 = new ASTCompoundTriggerBlock(this, JJTCOMPOUNDTRIGGERBLOCK);
27875 boolean jjtc000 = true;
27876 jjtree.openNodeScope(jjtn000);
27877 try {
27878 jj_consume_token(COMPOUND);
27879 jj_consume_token(TRIGGER);
27880 label_100:
27881 while (true) {
27882 switch (jj_nt.kind) {
27883 case REPLACE:
27884 case DEFINER:
27885 case CURRENT_USER:
27886 case SERIALLY_REUSABLE:
27887 case RESTRICT_REFERENCES:
27888 case EXCEPTION_INIT:
27889 case AUTONOMOUS_TRANSACTION:
27890 case LANGUAGE:
27891 case ADD:
27892 case AGGREGATE:
27893 case ALL:
27894 case ALTER:
27895 case AND:
27896 case ANY:
27897 case ARRAY:
27898 case AS:
27899 case ASC:
27900 case AT:
27901 case ATTRIBUTE:
27902 case AUTHID:
27903 case AVG:
27904 case BETWEEN:
27905 case BINARY_INTEGER:
27906 case BODY:
27907 case BOOLEAN:
27908 case BULK:
27909 case BY:
27910 case BYTE:
27911 case CASCADE:
27912 case CASE:
27913 case CHAR:
27914 case CHAR_BASE:
27915 case CHECK:
27916 case CLOSE:
27917 case CLUSTER:
27918 case COALESCE:
27919 case COLLECT:
27920 case COLUMN:
27921 case COMMENT:
27922 case COMMIT:
27923 case COMPRESS:
27924 case CONNECT:
27925 case CONSTANT:
27926 case CONSTRUCTOR:
27927 case CONTINUE:
27928 case CONVERT:
27929 case CREATE:
27930 case CURRENT:
27931 case CURRVAL:
27932 case CURSOR:
27933 case DATA:
27934 case DATE:
27935 case DAY:
27936 case DECLARE:
27937 case DECIMAL:
27938 case _DEFAULT:
27939 case DELETE:
27940 case DESC:
27941 case DISABLE:
27942 case DISTINCT:
27943 case DO:
27944 case DROP:
27945 case EDITIONABLE:
27946 case ELEMENT:
27947 case ELSE:
27948 case ELSIF:
27949 case ENABLE:
27950 case ESCAPE:
27951 case EXCEPT:
27952 case EXCEPTION:
27953 case EXCEPTIONS:
27954 case EXCLUSIVE:
27955 case EXECUTE:
27956 case EXISTS:
27957 case EXIT:
27958 case EXTERNAL:
27959 case EXTENDS:
27960 case EXTRACT:
27961 case FALSE:
27962 case FETCH:
27963 case FINAL:
27964 case FLOAT:
27965 case FOR:
27966 case FORALL:
27967 case FORCE:
27968 case FROM:
27969 case FUNCTION:
27970 case GLOBAL:
27971 case GOTO:
27972 case GROUP:
27973 case HASH:
27974 case HAVING:
27975 case HEAP:
27976 case HOUR:
27977 case IF:
27978 case IMMEDIATE:
27979 case IN:
27980 case INDEX:
27981 case INDICES:
27982 case INDEXTYPE:
27983 case INDICATOR:
27984 case INSERT:
27985 case INSTANTIABLE:
27986 case INTEGER:
27987 case INTERFACE:
27988 case INTERSECT:
27989 case INTERVAL:
27990 case INTO:
27991 case INVALIDATE:
27992 case IS:
27993 case ISOLATION:
27994 case JAVA:
27995 case LEVEL:
27996 case LIKE:
27997 case LIMIT:
27998 case LIMITED:
27999 case LOCK:
28000 case LONG:
28001 case LOOP:
28002 case MAP:
28003 case MAX:
28004 case MEMBER:
28005 case MERGE:
28006 case MIN:
28007 case MINUS:
28008 case MINUTE:
28009 case MLSLABEL:
28010 case MODIFY:
28011 case MOD:
28012 case MODE:
28013 case MONTH:
28014 case NATURAL:
28015 case NATURALN:
28016 case NEW:
28017 case NEXTVAL:
28018 case NO:
28019 case NOCOPY:
28020 case NONEDITIONABLE:
28021 case NOT:
28022 case NOWAIT:
28023 case NULL:
28024 case NULLIF:
28025 case NUMBER:
28026 case BFILE_BASE:
28027 case BLOB_BASE:
28028 case CLOB_BASE:
28029 case DATE_BASE:
28030 case NUMBER_BASE:
28031 case OBJECT:
28032 case OCIROWID:
28033 case OF:
28034 case OID:
28035 case ON:
28036 case OPAQUE:
28037 case OPEN:
28038 case OPERATOR:
28039 case OPTION:
28040 case OR:
28041 case ORDER:
28042 case ORGANIZATION:
28043 case OTHERS:
28044 case OUT:
28045 case OVERRIDING:
28046 case PACKAGE:
28047 case PARTITION:
28048 case PCTFREE:
28049 case PLS_INTEGER:
28050 case POSITIVE:
28051 case POSITIVEN:
28052 case PRAGMA:
28053 case PRESERVE:
28054 case PRIOR:
28055 case PROMPT:
28056 case PRIVATE:
28057 case PROCEDURE:
28058 case PUBLIC:
28059 case RAISE:
28060 case RANGE:
28061 case RAW:
28062 case REAL:
28063 case RECORD:
28064 case REF:
28065 case RELEASE:
28066 case RELIES_ON:
28067 case RENAME:
28068 case RESULT:
28069 case RETURN:
28070 case RETURNING:
28071 case REVERSE:
28072 case ROLLBACK:
28073 case ROW:
28074 case ROWS:
28075 case ROWID:
28076 case ROWNUM:
28077 case ROWTYPE:
28078 case SAVE:
28079 case SAVEPOINT:
28080 case SECOND:
28081 case SELECT:
28082 case SELF:
28083 case SEPARATE:
28084 case SET:
28085 case SHARE:
28086 case SMALLINT:
28087 case SPACE:
28088 case SQL:
28089 case SQLCODE:
28090 case SQLERRM:
28091 case START:
28092 case STATIC:
28093 case STDDEV:
28094 case SUBTYPE:
28095 case SUBSTITUTABLE:
28096 case SUCCESSFUL:
28097 case SUM:
28098 case SYNONYM:
28099 case SYSDATE:
28100 case SYS_REFCURSOR:
28101 case TABLE:
28102 case TEMPORARY:
28103 case THEN:
28104 case TIME:
28105 case TIMESTAMP:
28106 case TIMEZONE_REGION:
28107 case TIMEZONE_ABBR:
28108 case TIMEZONE_MINUTE:
28109 case TIMEZONE_HOUR:
28110 case TO:
28111 case TRANSACTION:
28112 case TRIGGER:
28113 case TRUE:
28114 case TYPE:
28115 case UI:
28116 case UNDER:
28117 case USING:
28118 case WHILE:
28119 case YES:
28120 case SHOW:
28121 case A:
28122 case UPDATE:
28123 case VARCHAR:
28124 case VARCHAR2:
28125 case DOUBLE:
28126 case DEC:
28127 case PRECISION:
28128 case INT:
28129 case NUMERIC:
28130 case SIGNTYPE:
28131 case NCHAR:
28132 case NVARCHAR2:
28133 case STRING:
28134 case UROWID:
28135 case VARRAY:
28136 case VARYING:
28137 case BFILE:
28138 case BLOB:
28139 case CLOB:
28140 case NCLOB:
28141 case YEAR:
28142 case LOCAL:
28143 case WITH:
28144 case ZONE:
28145 case CHARACTER:
28146 case AFTER:
28147 case BEFORE:
28148 case INSTEADOF:
28149 case OLD:
28150 case PARENT:
28151 case ANALYZE:
28152 case ASSOCIATE:
28153 case AUDIT:
28154 case COMPOUND:
28155 case DATABASE:
28156 case CALL:
28157 case DDL:
28158 case DISASSOCIATE:
28159 case EACH:
28160 case FOLLOWS:
28161 case LOGOFF:
28162 case LOGON:
28163 case NESTED:
28164 case NOAUDIT:
28165 case SCHEMA:
28166 case SERVERERROR:
28167 case SHUTDOWN:
28168 case STARTUP:
28169 case STATEMENT:
28170 case STATISTICS:
28171 case SUSPEND:
28172 case TRUNCATE:
28173 case WRAPPED:
28174 case LIBRARY:
28175 case NAME:
28176 case STRUCT:
28177 case CONTEXT:
28178 case PARAMETERS:
28179 case LENGTH:
28180 case TDO:
28181 case MAXLEN:
28182 case CHARSETID:
28183 case CHARSETFORM:
28184 case ACCEPT:
28185 case ACCESSIBLE:
28186 case COPY:
28187 case DEFINE:
28188 case DISCONNECT:
28189 case HOST:
28190 case PRINT:
28191 case QUIT:
28192 case REMARK:
28193 case UNDEFINE:
28194 case VARIABLE:
28195 case WHENEVER:
28196 case ATTACH:
28197 case CAST:
28198 case TREAT:
28199 case TRIM:
28200 case LEFT:
28201 case RIGHT:
28202 case BOTH:
28203 case EMPTY:
28204 case MULTISET:
28205 case SUBMULTISET:
28206 case LEADING:
28207 case TRAILING:
28208 case CHAR_CS:
28209 case NCHAR_CS:
28210 case DBTIMEZONE:
28211 case SESSIONTIMEZONE:
28212 case AUTHENTICATED:
28213 case LINK:
28214 case SHARED:
28215 case DIRECTORY:
28216 case USER:
28217 case IDENTIFIER:
28218 case QUOTED_LITERAL:
28219 case SQLDATA_CLASS:
28220 case CUSTOMDATUM_CLASS:
28221 case ORADATA_CLASS:
28222 case JAVA_INTERFACE_CLASS:
28223 ;
28224 break;
28225 default:
28226 jj_la1[428] = jj_gen;
28227 break label_100;
28228 }
28229 switch (jj_nt.kind) {
28230 case AFTER:
28231 case BEFORE:
28232 case INSTEADOF:
28233 TriggerTimingPointSection();
28234 break;
28235 case PRAGMA:
28236 Pragma();
28237 break;
28238 default:
28239 jj_la1[429] = jj_gen;
28240 if (jj_2_79(2)) {
28241 ExceptionDeclaration();
28242 } else if (jj_2_80(2)) {
28243 SubTypeDefinition();
28244 } else if (jj_2_81(4)) {
28245 VariableOrConstantDeclaration();
28246 } else if (jj_2_82(2)) {
28247 CursorSpecification();
28248 } else {
28249 switch (jj_nt.kind) {
28250 case CURSOR:
28251 CursorBody();
28252 break;
28253 case IDENTIFIER:
28254 CollectionDeclaration();
28255 break;
28256 case CREATE:
28257 case FUNCTION:
28258 case PROCEDURE:
28259 ProgramUnit();
28260 break;
28261 default:
28262 jj_la1[430] = jj_gen;
28263 jj_consume_token(-1);
28264 throw new ParseException();
28265 }
28266 }
28267 }
28268 }
28269 jj_consume_token(END);
28270 switch (jj_nt.kind) {
28271 case REPLACE:
28272 case DEFINER:
28273 case CURRENT_USER:
28274 case SERIALLY_REUSABLE:
28275 case RESTRICT_REFERENCES:
28276 case EXCEPTION_INIT:
28277 case AUTONOMOUS_TRANSACTION:
28278 case LANGUAGE:
28279 case ADD:
28280 case AGGREGATE:
28281 case ALL:
28282 case ALTER:
28283 case AND:
28284 case ANY:
28285 case ARRAY:
28286 case AS:
28287 case ASC:
28288 case AT:
28289 case ATTRIBUTE:
28290 case AUTHID:
28291 case AVG:
28292 case BETWEEN:
28293 case BINARY_INTEGER:
28294 case BODY:
28295 case BOOLEAN:
28296 case BULK:
28297 case BY:
28298 case BYTE:
28299 case CASCADE:
28300 case CASE:
28301 case CHAR:
28302 case CHAR_BASE:
28303 case CHECK:
28304 case CLOSE:
28305 case CLUSTER:
28306 case COALESCE:
28307 case COLLECT:
28308 case COLUMN:
28309 case COMMENT:
28310 case COMMIT:
28311 case COMPRESS:
28312 case CONNECT:
28313 case CONSTANT:
28314 case CONSTRUCTOR:
28315 case CONTINUE:
28316 case CONVERT:
28317 case CREATE:
28318 case CURRENT:
28319 case CURRVAL:
28320 case CURSOR:
28321 case DATA:
28322 case DATE:
28323 case DAY:
28324 case DECLARE:
28325 case DECIMAL:
28326 case _DEFAULT:
28327 case DELETE:
28328 case DESC:
28329 case DISABLE:
28330 case DISTINCT:
28331 case DO:
28332 case DROP:
28333 case EDITIONABLE:
28334 case ELEMENT:
28335 case ELSE:
28336 case ELSIF:
28337 case ENABLE:
28338 case ESCAPE:
28339 case EXCEPT:
28340 case EXCEPTION:
28341 case EXCEPTIONS:
28342 case EXCLUSIVE:
28343 case EXECUTE:
28344 case EXISTS:
28345 case EXIT:
28346 case EXTERNAL:
28347 case EXTENDS:
28348 case EXTRACT:
28349 case FALSE:
28350 case FETCH:
28351 case FINAL:
28352 case FLOAT:
28353 case FOR:
28354 case FORALL:
28355 case FORCE:
28356 case FROM:
28357 case FUNCTION:
28358 case GLOBAL:
28359 case GOTO:
28360 case GROUP:
28361 case HASH:
28362 case HAVING:
28363 case HEAP:
28364 case HOUR:
28365 case IF:
28366 case IMMEDIATE:
28367 case IN:
28368 case INDEX:
28369 case INDICES:
28370 case INDEXTYPE:
28371 case INDICATOR:
28372 case INSERT:
28373 case INSTANTIABLE:
28374 case INTEGER:
28375 case INTERFACE:
28376 case INTERSECT:
28377 case INTERVAL:
28378 case INTO:
28379 case INVALIDATE:
28380 case IS:
28381 case ISOLATION:
28382 case JAVA:
28383 case LEVEL:
28384 case LIKE:
28385 case LIMIT:
28386 case LIMITED:
28387 case LOCK:
28388 case LONG:
28389 case LOOP:
28390 case MAP:
28391 case MAX:
28392 case MEMBER:
28393 case MERGE:
28394 case MIN:
28395 case MINUS:
28396 case MINUTE:
28397 case MLSLABEL:
28398 case MODIFY:
28399 case MOD:
28400 case MODE:
28401 case MONTH:
28402 case NATURAL:
28403 case NATURALN:
28404 case NEW:
28405 case NEXTVAL:
28406 case NO:
28407 case NOCOPY:
28408 case NONEDITIONABLE:
28409 case NOT:
28410 case NOWAIT:
28411 case NULL:
28412 case NULLIF:
28413 case NUMBER:
28414 case BFILE_BASE:
28415 case BLOB_BASE:
28416 case CLOB_BASE:
28417 case DATE_BASE:
28418 case NUMBER_BASE:
28419 case OBJECT:
28420 case OCIROWID:
28421 case OF:
28422 case OID:
28423 case ON:
28424 case OPAQUE:
28425 case OPEN:
28426 case OPERATOR:
28427 case OPTION:
28428 case OR:
28429 case ORDER:
28430 case ORGANIZATION:
28431 case OTHERS:
28432 case OUT:
28433 case OVERRIDING:
28434 case PACKAGE:
28435 case PARTITION:
28436 case PCTFREE:
28437 case PLS_INTEGER:
28438 case POSITIVE:
28439 case POSITIVEN:
28440 case PRESERVE:
28441 case PRIOR:
28442 case PROMPT:
28443 case PRIVATE:
28444 case PROCEDURE:
28445 case PUBLIC:
28446 case RAISE:
28447 case RANGE:
28448 case RAW:
28449 case REAL:
28450 case RECORD:
28451 case REF:
28452 case RELEASE:
28453 case RELIES_ON:
28454 case RENAME:
28455 case RESULT:
28456 case RETURN:
28457 case RETURNING:
28458 case REVERSE:
28459 case ROLLBACK:
28460 case ROW:
28461 case ROWS:
28462 case ROWID:
28463 case ROWNUM:
28464 case ROWTYPE:
28465 case SAVE:
28466 case SAVEPOINT:
28467 case SECOND:
28468 case SELECT:
28469 case SELF:
28470 case SEPARATE:
28471 case SET:
28472 case SHARE:
28473 case SMALLINT:
28474 case SPACE:
28475 case SQL:
28476 case SQLCODE:
28477 case SQLERRM:
28478 case START:
28479 case STATIC:
28480 case STDDEV:
28481 case SUBTYPE:
28482 case SUBSTITUTABLE:
28483 case SUCCESSFUL:
28484 case SUM:
28485 case SYNONYM:
28486 case SYSDATE:
28487 case SYS_REFCURSOR:
28488 case TABLE:
28489 case TEMPORARY:
28490 case THEN:
28491 case TIME:
28492 case TIMESTAMP:
28493 case TIMEZONE_REGION:
28494 case TIMEZONE_ABBR:
28495 case TIMEZONE_MINUTE:
28496 case TIMEZONE_HOUR:
28497 case TO:
28498 case TRANSACTION:
28499 case TRIGGER:
28500 case TRUE:
28501 case TYPE:
28502 case UI:
28503 case UNDER:
28504 case USING:
28505 case WHILE:
28506 case YES:
28507 case SHOW:
28508 case A:
28509 case UPDATE:
28510 case VARCHAR:
28511 case VARCHAR2:
28512 case DOUBLE:
28513 case DEC:
28514 case PRECISION:
28515 case INT:
28516 case NUMERIC:
28517 case SIGNTYPE:
28518 case NCHAR:
28519 case NVARCHAR2:
28520 case STRING:
28521 case UROWID:
28522 case VARRAY:
28523 case VARYING:
28524 case BFILE:
28525 case BLOB:
28526 case CLOB:
28527 case NCLOB:
28528 case YEAR:
28529 case LOCAL:
28530 case WITH:
28531 case ZONE:
28532 case CHARACTER:
28533 case AFTER:
28534 case BEFORE:
28535 case OLD:
28536 case PARENT:
28537 case ANALYZE:
28538 case ASSOCIATE:
28539 case AUDIT:
28540 case COMPOUND:
28541 case DATABASE:
28542 case CALL:
28543 case DDL:
28544 case DISASSOCIATE:
28545 case EACH:
28546 case FOLLOWS:
28547 case LOGOFF:
28548 case LOGON:
28549 case NESTED:
28550 case NOAUDIT:
28551 case SCHEMA:
28552 case SERVERERROR:
28553 case SHUTDOWN:
28554 case STARTUP:
28555 case STATEMENT:
28556 case STATISTICS:
28557 case SUSPEND:
28558 case TRUNCATE:
28559 case WRAPPED:
28560 case LIBRARY:
28561 case NAME:
28562 case STRUCT:
28563 case CONTEXT:
28564 case PARAMETERS:
28565 case LENGTH:
28566 case TDO:
28567 case MAXLEN:
28568 case CHARSETID:
28569 case CHARSETFORM:
28570 case ACCEPT:
28571 case ACCESSIBLE:
28572 case COPY:
28573 case DEFINE:
28574 case DISCONNECT:
28575 case HOST:
28576 case PRINT:
28577 case QUIT:
28578 case REMARK:
28579 case UNDEFINE:
28580 case VARIABLE:
28581 case WHENEVER:
28582 case ATTACH:
28583 case CAST:
28584 case TREAT:
28585 case TRIM:
28586 case LEFT:
28587 case RIGHT:
28588 case BOTH:
28589 case EMPTY:
28590 case MULTISET:
28591 case SUBMULTISET:
28592 case LEADING:
28593 case TRAILING:
28594 case CHAR_CS:
28595 case NCHAR_CS:
28596 case DBTIMEZONE:
28597 case SESSIONTIMEZONE:
28598 case AUTHENTICATED:
28599 case LINK:
28600 case SHARED:
28601 case DIRECTORY:
28602 case USER:
28603 case IDENTIFIER:
28604 case QUOTED_LITERAL:
28605 case SQLDATA_CLASS:
28606 case CUSTOMDATUM_CLASS:
28607 case ORADATA_CLASS:
28608 case JAVA_INTERFACE_CLASS:
28609 ID();
28610 break;
28611 default:
28612 jj_la1[431] = jj_gen;
28613 ;
28614 }
28615 jj_consume_token(4);
28616 jjtree.closeNodeScope(jjtn000, true);
28617 jjtc000 = false;
28618 {if (true) return jjtn000 ;}
28619 } catch (Throwable jjte000) {
28620 if (jjtc000) {
28621 jjtree.clearNodeScope(jjtn000);
28622 jjtc000 = false;
28623 } else {
28624 jjtree.popNode();
28625 }
28626 if (jjte000 instanceof RuntimeException) {
28627 {if (true) throw (RuntimeException)jjte000;}
28628 }
28629 if (jjte000 instanceof ParseException) {
28630 {if (true) throw (ParseException)jjte000;}
28631 }
28632 {if (true) throw (Error)jjte000;}
28633 } finally {
28634 if (jjtc000) {
28635 jjtree.closeNodeScope(jjtn000, true);
28636 }
28637 }
28638 throw new Error("Missing return statement in function");
28639 }
28640
28641
28642
28643
28644
28645
28646
28647
28648 final public ASTNonDMLTrigger NonDMLTrigger() throws ParseException {
28649
28650 ASTNonDMLTrigger jjtn000 = new ASTNonDMLTrigger(this, JJTNONDMLTRIGGER);
28651 boolean jjtc000 = true;
28652 jjtree.openNodeScope(jjtn000);
28653 try {
28654 switch (jj_nt.kind) {
28655 case BEFORE:
28656 jj_consume_token(BEFORE);
28657 break;
28658 case AFTER:
28659 jj_consume_token(AFTER);
28660 break;
28661 default:
28662 jj_la1[432] = jj_gen;
28663 jj_consume_token(-1);
28664 throw new ParseException();
28665 }
28666 switch (jj_nt.kind) {
28667 case ALTER:
28668 case COMMENT:
28669 case CREATE:
28670 case DROP:
28671 case GRANT:
28672 case RENAME:
28673 case REVOKE:
28674 case ANALYZE:
28675 case ASSOCIATE:
28676 case AUDIT:
28677 case DDL:
28678 case DISASSOCIATE:
28679 case NOAUDIT:
28680 case TRUNCATE:
28681 DDLEvent();
28682 break;
28683 case LOGOFF:
28684 case LOGON:
28685 case SERVERERROR:
28686 case SHUTDOWN:
28687 case STARTUP:
28688 case SUSPEND:
28689 DatabaseEvent();
28690 break;
28691 default:
28692 jj_la1[433] = jj_gen;
28693 jj_consume_token(-1);
28694 throw new ParseException();
28695 }
28696 label_101:
28697 while (true) {
28698 switch (jj_nt.kind) {
28699 case OR:
28700 ;
28701 break;
28702 default:
28703 jj_la1[434] = jj_gen;
28704 break label_101;
28705 }
28706 jj_consume_token(OR);
28707 switch (jj_nt.kind) {
28708 case ALTER:
28709 case COMMENT:
28710 case CREATE:
28711 case DROP:
28712 case GRANT:
28713 case RENAME:
28714 case REVOKE:
28715 case ANALYZE:
28716 case ASSOCIATE:
28717 case AUDIT:
28718 case DDL:
28719 case DISASSOCIATE:
28720 case NOAUDIT:
28721 case TRUNCATE:
28722 DDLEvent();
28723 break;
28724 case LOGOFF:
28725 case LOGON:
28726 case SERVERERROR:
28727 case SHUTDOWN:
28728 case STARTUP:
28729 case SUSPEND:
28730 DatabaseEvent();
28731 break;
28732 default:
28733 jj_la1[435] = jj_gen;
28734 jj_consume_token(-1);
28735 throw new ParseException();
28736 }
28737 }
28738 jj_consume_token(ON);
28739 switch (jj_nt.kind) {
28740 case DATABASE:
28741 jj_consume_token(DATABASE);
28742 break;
28743 case REPLACE:
28744 case DEFINER:
28745 case CURRENT_USER:
28746 case SERIALLY_REUSABLE:
28747 case RESTRICT_REFERENCES:
28748 case EXCEPTION_INIT:
28749 case AUTONOMOUS_TRANSACTION:
28750 case LANGUAGE:
28751 case ADD:
28752 case AGGREGATE:
28753 case ALL:
28754 case ALTER:
28755 case AND:
28756 case ANY:
28757 case ARRAY:
28758 case AS:
28759 case ASC:
28760 case AT:
28761 case ATTRIBUTE:
28762 case AUTHID:
28763 case AVG:
28764 case BETWEEN:
28765 case BINARY_INTEGER:
28766 case BODY:
28767 case BOOLEAN:
28768 case BULK:
28769 case BY:
28770 case BYTE:
28771 case CASCADE:
28772 case CASE:
28773 case CHAR:
28774 case CHAR_BASE:
28775 case CHECK:
28776 case CLOSE:
28777 case CLUSTER:
28778 case COALESCE:
28779 case COLLECT:
28780 case COLUMN:
28781 case COMMENT:
28782 case COMMIT:
28783 case COMPRESS:
28784 case CONNECT:
28785 case CONSTANT:
28786 case CONSTRUCTOR:
28787 case CONTINUE:
28788 case CONVERT:
28789 case CREATE:
28790 case CURRENT:
28791 case CURRVAL:
28792 case CURSOR:
28793 case DATA:
28794 case DATE:
28795 case DAY:
28796 case DECLARE:
28797 case DECIMAL:
28798 case _DEFAULT:
28799 case DELETE:
28800 case DESC:
28801 case DISABLE:
28802 case DISTINCT:
28803 case DO:
28804 case DROP:
28805 case EDITIONABLE:
28806 case ELEMENT:
28807 case ELSE:
28808 case ELSIF:
28809 case ENABLE:
28810 case ESCAPE:
28811 case EXCEPT:
28812 case EXCEPTION:
28813 case EXCEPTIONS:
28814 case EXCLUSIVE:
28815 case EXECUTE:
28816 case EXISTS:
28817 case EXIT:
28818 case EXTERNAL:
28819 case EXTENDS:
28820 case EXTRACT:
28821 case FALSE:
28822 case FETCH:
28823 case FINAL:
28824 case FLOAT:
28825 case FOR:
28826 case FORALL:
28827 case FORCE:
28828 case FROM:
28829 case FUNCTION:
28830 case GLOBAL:
28831 case GOTO:
28832 case GROUP:
28833 case HASH:
28834 case HAVING:
28835 case HEAP:
28836 case HOUR:
28837 case IF:
28838 case IMMEDIATE:
28839 case IN:
28840 case INDEX:
28841 case INDICES:
28842 case INDEXTYPE:
28843 case INDICATOR:
28844 case INSERT:
28845 case INSTANTIABLE:
28846 case INTEGER:
28847 case INTERFACE:
28848 case INTERSECT:
28849 case INTERVAL:
28850 case INTO:
28851 case INVALIDATE:
28852 case IS:
28853 case ISOLATION:
28854 case JAVA:
28855 case LEVEL:
28856 case LIKE:
28857 case LIMIT:
28858 case LIMITED:
28859 case LOCK:
28860 case LONG:
28861 case LOOP:
28862 case MAP:
28863 case MAX:
28864 case MEMBER:
28865 case MERGE:
28866 case MIN:
28867 case MINUS:
28868 case MINUTE:
28869 case MLSLABEL:
28870 case MODIFY:
28871 case MOD:
28872 case MODE:
28873 case MONTH:
28874 case NATURAL:
28875 case NATURALN:
28876 case NEW:
28877 case NEXTVAL:
28878 case NO:
28879 case NOCOPY:
28880 case NONEDITIONABLE:
28881 case NOT:
28882 case NOWAIT:
28883 case NULL:
28884 case NULLIF:
28885 case NUMBER:
28886 case BFILE_BASE:
28887 case BLOB_BASE:
28888 case CLOB_BASE:
28889 case DATE_BASE:
28890 case NUMBER_BASE:
28891 case OBJECT:
28892 case OCIROWID:
28893 case OF:
28894 case OID:
28895 case ON:
28896 case OPAQUE:
28897 case OPEN:
28898 case OPERATOR:
28899 case OPTION:
28900 case OR:
28901 case ORDER:
28902 case ORGANIZATION:
28903 case OTHERS:
28904 case OUT:
28905 case OVERRIDING:
28906 case PACKAGE:
28907 case PARTITION:
28908 case PCTFREE:
28909 case PLS_INTEGER:
28910 case POSITIVE:
28911 case POSITIVEN:
28912 case PRESERVE:
28913 case PRIOR:
28914 case PROMPT:
28915 case PRIVATE:
28916 case PROCEDURE:
28917 case PUBLIC:
28918 case RAISE:
28919 case RANGE:
28920 case RAW:
28921 case REAL:
28922 case RECORD:
28923 case REF:
28924 case RELEASE:
28925 case RELIES_ON:
28926 case RENAME:
28927 case RESULT:
28928 case RETURN:
28929 case RETURNING:
28930 case REVERSE:
28931 case ROLLBACK:
28932 case ROW:
28933 case ROWS:
28934 case ROWID:
28935 case ROWNUM:
28936 case ROWTYPE:
28937 case SAVE:
28938 case SAVEPOINT:
28939 case SECOND:
28940 case SELECT:
28941 case SELF:
28942 case SEPARATE:
28943 case SET:
28944 case SHARE:
28945 case SMALLINT:
28946 case SPACE:
28947 case SQL:
28948 case SQLCODE:
28949 case SQLERRM:
28950 case START:
28951 case STATIC:
28952 case STDDEV:
28953 case SUBTYPE:
28954 case SUBSTITUTABLE:
28955 case SUCCESSFUL:
28956 case SUM:
28957 case SYNONYM:
28958 case SYSDATE:
28959 case SYS_REFCURSOR:
28960 case TABLE:
28961 case TEMPORARY:
28962 case THEN:
28963 case TIME:
28964 case TIMESTAMP:
28965 case TIMEZONE_REGION:
28966 case TIMEZONE_ABBR:
28967 case TIMEZONE_MINUTE:
28968 case TIMEZONE_HOUR:
28969 case TO:
28970 case TRANSACTION:
28971 case TRIGGER:
28972 case TRUE:
28973 case TYPE:
28974 case UI:
28975 case UNDER:
28976 case USING:
28977 case WHILE:
28978 case YES:
28979 case SHOW:
28980 case A:
28981 case UPDATE:
28982 case VARCHAR:
28983 case VARCHAR2:
28984 case DOUBLE:
28985 case DEC:
28986 case PRECISION:
28987 case INT:
28988 case NUMERIC:
28989 case SIGNTYPE:
28990 case NCHAR:
28991 case NVARCHAR2:
28992 case STRING:
28993 case UROWID:
28994 case VARRAY:
28995 case VARYING:
28996 case BFILE:
28997 case BLOB:
28998 case CLOB:
28999 case NCLOB:
29000 case YEAR:
29001 case LOCAL:
29002 case WITH:
29003 case ZONE:
29004 case CHARACTER:
29005 case AFTER:
29006 case BEFORE:
29007 case OLD:
29008 case PARENT:
29009 case ANALYZE:
29010 case ASSOCIATE:
29011 case AUDIT:
29012 case COMPOUND:
29013 case CALL:
29014 case DDL:
29015 case DISASSOCIATE:
29016 case EACH:
29017 case FOLLOWS:
29018 case LOGOFF:
29019 case LOGON:
29020 case NESTED:
29021 case NOAUDIT:
29022 case SCHEMA:
29023 case SERVERERROR:
29024 case SHUTDOWN:
29025 case STARTUP:
29026 case STATEMENT:
29027 case STATISTICS:
29028 case SUSPEND:
29029 case TRUNCATE:
29030 case WRAPPED:
29031 case LIBRARY:
29032 case NAME:
29033 case STRUCT:
29034 case CONTEXT:
29035 case PARAMETERS:
29036 case LENGTH:
29037 case TDO:
29038 case MAXLEN:
29039 case CHARSETID:
29040 case CHARSETFORM:
29041 case ACCEPT:
29042 case ACCESSIBLE:
29043 case COPY:
29044 case DEFINE:
29045 case DISCONNECT:
29046 case HOST:
29047 case PRINT:
29048 case QUIT:
29049 case REMARK:
29050 case UNDEFINE:
29051 case VARIABLE:
29052 case WHENEVER:
29053 case ATTACH:
29054 case CAST:
29055 case TREAT:
29056 case TRIM:
29057 case LEFT:
29058 case RIGHT:
29059 case BOTH:
29060 case EMPTY:
29061 case MULTISET:
29062 case SUBMULTISET:
29063 case LEADING:
29064 case TRAILING:
29065 case CHAR_CS:
29066 case NCHAR_CS:
29067 case DBTIMEZONE:
29068 case SESSIONTIMEZONE:
29069 case AUTHENTICATED:
29070 case LINK:
29071 case SHARED:
29072 case DIRECTORY:
29073 case USER:
29074 case IDENTIFIER:
29075 case QUOTED_LITERAL:
29076 case SQLDATA_CLASS:
29077 case CUSTOMDATUM_CLASS:
29078 case ORADATA_CLASS:
29079 case JAVA_INTERFACE_CLASS:
29080 if (jj_2_83(2)) {
29081 ID();
29082 jj_consume_token(3);
29083 } else {
29084 ;
29085 }
29086 jj_consume_token(SCHEMA);
29087 break;
29088 default:
29089 jj_la1[436] = jj_gen;
29090 jj_consume_token(-1);
29091 throw new ParseException();
29092 }
29093 jjtree.closeNodeScope(jjtn000, true);
29094 jjtc000 = false;
29095 {if (true) return jjtn000 ;}
29096 } catch (Throwable jjte000) {
29097 if (jjtc000) {
29098 jjtree.clearNodeScope(jjtn000);
29099 jjtc000 = false;
29100 } else {
29101 jjtree.popNode();
29102 }
29103 if (jjte000 instanceof RuntimeException) {
29104 {if (true) throw (RuntimeException)jjte000;}
29105 }
29106 if (jjte000 instanceof ParseException) {
29107 {if (true) throw (ParseException)jjte000;}
29108 }
29109 {if (true) throw (Error)jjte000;}
29110 } finally {
29111 if (jjtc000) {
29112 jjtree.closeNodeScope(jjtn000, true);
29113 }
29114 }
29115 throw new Error("Missing return statement in function");
29116 }
29117
29118 final public ASTDDLEvent DDLEvent() throws ParseException {
29119
29120 ASTDDLEvent jjtn000 = new ASTDDLEvent(this, JJTDDLEVENT);
29121 boolean jjtc000 = true;
29122 jjtree.openNodeScope(jjtn000);
29123 try {
29124 switch (jj_nt.kind) {
29125 case ALTER:
29126 jj_consume_token(ALTER);
29127 break;
29128 case ANALYZE:
29129 jj_consume_token(ANALYZE);
29130 break;
29131 case ASSOCIATE:
29132 jj_consume_token(ASSOCIATE);
29133 jj_consume_token(STATISTICS);
29134 break;
29135 case AUDIT:
29136 jj_consume_token(AUDIT);
29137 break;
29138 case COMMENT:
29139 jj_consume_token(COMMENT);
29140 break;
29141 case CREATE:
29142 jj_consume_token(CREATE);
29143 break;
29144 case DISASSOCIATE:
29145 jj_consume_token(DISASSOCIATE);
29146 jj_consume_token(STATISTICS);
29147 break;
29148 case DROP:
29149 jj_consume_token(DROP);
29150 break;
29151 case GRANT:
29152 jj_consume_token(GRANT);
29153 break;
29154 case NOAUDIT:
29155 jj_consume_token(NOAUDIT);
29156 break;
29157 case RENAME:
29158 jj_consume_token(RENAME);
29159 break;
29160 case REVOKE:
29161 jj_consume_token(REVOKE);
29162 break;
29163 case TRUNCATE:
29164 jj_consume_token(TRUNCATE);
29165 break;
29166 case DDL:
29167 jj_consume_token(DDL);
29168 break;
29169 default:
29170 jj_la1[437] = jj_gen;
29171 jj_consume_token(-1);
29172 throw new ParseException();
29173 }
29174 jjtree.closeNodeScope(jjtn000, true);
29175 jjtc000 = false;
29176 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29177 } finally {
29178 if (jjtc000) {
29179 jjtree.closeNodeScope(jjtn000, true);
29180 }
29181 }
29182 throw new Error("Missing return statement in function");
29183 }
29184
29185 final public ASTDatabaseEvent DatabaseEvent() throws ParseException {
29186
29187 ASTDatabaseEvent jjtn000 = new ASTDatabaseEvent(this, JJTDATABASEEVENT);
29188 boolean jjtc000 = true;
29189 jjtree.openNodeScope(jjtn000);
29190 try {
29191 switch (jj_nt.kind) {
29192 case STARTUP:
29193 jj_consume_token(STARTUP);
29194 break;
29195 case SHUTDOWN:
29196 jj_consume_token(SHUTDOWN);
29197 break;
29198 case LOGON:
29199 jj_consume_token(LOGON);
29200 break;
29201 case LOGOFF:
29202 jj_consume_token(LOGOFF);
29203 break;
29204 case SERVERERROR:
29205 jj_consume_token(SERVERERROR);
29206 break;
29207 case SUSPEND:
29208 jj_consume_token(SUSPEND);
29209 break;
29210 default:
29211 jj_la1[438] = jj_gen;
29212 jj_consume_token(-1);
29213 throw new ParseException();
29214 }
29215 jjtree.closeNodeScope(jjtn000, true);
29216 jjtc000 = false;
29217 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29218 } finally {
29219 if (jjtc000) {
29220 jjtree.closeNodeScope(jjtn000, true);
29221 }
29222 }
29223 throw new Error("Missing return statement in function");
29224 }
29225
29226 final public ASTNonDMLEvent NonDMLEvent() throws ParseException {
29227
29228 ASTNonDMLEvent jjtn000 = new ASTNonDMLEvent(this, JJTNONDMLEVENT);
29229 boolean jjtc000 = true;
29230 jjtree.openNodeScope(jjtn000);
29231 try {
29232 switch (jj_nt.kind) {
29233 case ALTER:
29234 case COMMENT:
29235 case CREATE:
29236 case DROP:
29237 case GRANT:
29238 case RENAME:
29239 case REVOKE:
29240 case ANALYZE:
29241 case ASSOCIATE:
29242 case AUDIT:
29243 case DDL:
29244 case DISASSOCIATE:
29245 case NOAUDIT:
29246 case TRUNCATE:
29247 DDLEvent();
29248 break;
29249 case LOGOFF:
29250 case LOGON:
29251 case SERVERERROR:
29252 case SHUTDOWN:
29253 case STARTUP:
29254 case SUSPEND:
29255 DatabaseEvent();
29256 break;
29257 default:
29258 jj_la1[439] = jj_gen;
29259 jj_consume_token(-1);
29260 throw new ParseException();
29261 }
29262 jjtree.closeNodeScope(jjtn000, true);
29263 jjtc000 = false;
29264 {if (true) return jjtn000;}
29265 } catch (Throwable jjte000) {
29266 if (jjtc000) {
29267 jjtree.clearNodeScope(jjtn000);
29268 jjtc000 = false;
29269 } else {
29270 jjtree.popNode();
29271 }
29272 if (jjte000 instanceof RuntimeException) {
29273 {if (true) throw (RuntimeException)jjte000;}
29274 }
29275 if (jjte000 instanceof ParseException) {
29276 {if (true) throw (ParseException)jjte000;}
29277 }
29278 {if (true) throw (Error)jjte000;}
29279 } finally {
29280 if (jjtc000) {
29281 jjtree.closeNodeScope(jjtn000, true);
29282 }
29283 }
29284 throw new Error("Missing return statement in function");
29285 }
29286
29287
29288
29289
29290
29291
29292
29293
29294 final public void AlterTrigger() throws ParseException {
29295
29296 ASTAlterTrigger jjtn000 = new ASTAlterTrigger(this, JJTALTERTRIGGER);
29297 boolean jjtc000 = true;
29298 jjtree.openNodeScope(jjtn000);
29299 try {
29300 jj_consume_token(ALTER);
29301 jj_consume_token(TRIGGER);
29302 Skip2NextTerminator(null,";");
29303 jj_consume_token(4);
29304 jjtree.closeNodeScope(jjtn000, true);
29305 jjtc000 = false;
29306 {if (true) return;}
29307 } catch (Throwable jjte000) {
29308 if (jjtc000) {
29309 jjtree.clearNodeScope(jjtn000);
29310 jjtc000 = false;
29311 } else {
29312 jjtree.popNode();
29313 }
29314 if (jjte000 instanceof RuntimeException) {
29315 {if (true) throw (RuntimeException)jjte000;}
29316 }
29317 if (jjte000 instanceof ParseException) {
29318 {if (true) throw (ParseException)jjte000;}
29319 }
29320 {if (true) throw (Error)jjte000;}
29321 } finally {
29322 if (jjtc000) {
29323 jjtree.closeNodeScope(jjtn000, true);
29324 }
29325 }
29326 }
29327
29328
29329 final public ASTKEYWORD_RESERVED KEYWORD_RESERVED() throws ParseException {
29330
29331 ASTKEYWORD_RESERVED jjtn000 = new ASTKEYWORD_RESERVED(this, JJTKEYWORD_RESERVED);
29332 boolean jjtc000 = true;
29333 jjtree.openNodeScope(jjtn000);
29334 try {
29335 switch (jj_nt.kind) {
29336 case ALL:
29337 jj_consume_token(ALL);
29338 break;
29339 case ALTER:
29340 jj_consume_token(ALTER);
29341 break;
29342 case AND:
29343 jj_consume_token(AND);
29344 break;
29345 case ANY:
29346 jj_consume_token(ANY);
29347 break;
29348 case AS:
29349 jj_consume_token(AS);
29350 break;
29351 case ASC:
29352 jj_consume_token(ASC);
29353 break;
29354 case BETWEEN:
29355 jj_consume_token(BETWEEN);
29356 break;
29357 case BY:
29358 jj_consume_token(BY);
29359 break;
29360 case CHAR:
29361 jj_consume_token(CHAR);
29362 break;
29363 case CHECK:
29364 jj_consume_token(CHECK);
29365 break;
29366 case CLUSTER:
29367 jj_consume_token(CLUSTER);
29368 break;
29369 case COMPRESS:
29370 jj_consume_token(COMPRESS);
29371 break;
29372 case CONNECT:
29373 jj_consume_token(CONNECT);
29374 break;
29375 case CREATE:
29376 jj_consume_token(CREATE);
29377 break;
29378 case DATE:
29379 jj_consume_token(DATE);
29380 break;
29381 case DECIMAL:
29382 jj_consume_token(DECIMAL);
29383 break;
29384 case _DEFAULT:
29385 jj_consume_token(_DEFAULT);
29386 break;
29387 case DELETE:
29388 jj_consume_token(DELETE);
29389 break;
29390 case DESC:
29391 jj_consume_token(DESC);
29392 break;
29393 case DISTINCT:
29394 jj_consume_token(DISTINCT);
29395 break;
29396 case DROP:
29397 jj_consume_token(DROP);
29398 break;
29399 case ELSE:
29400 jj_consume_token(ELSE);
29401 break;
29402 case EXCLUSIVE:
29403 jj_consume_token(EXCLUSIVE);
29404 break;
29405 case EXISTS:
29406 jj_consume_token(EXISTS);
29407 break;
29408 case FLOAT:
29409 jj_consume_token(FLOAT);
29410 break;
29411 case FOR:
29412 jj_consume_token(FOR);
29413 break;
29414 case FROM:
29415 jj_consume_token(FROM);
29416 break;
29417 case GRANT:
29418 jj_consume_token(GRANT);
29419 break;
29420 case GROUP:
29421 jj_consume_token(GROUP);
29422 break;
29423 case HAVING:
29424 jj_consume_token(HAVING);
29425 break;
29426 case IDENTIFIED:
29427 jj_consume_token(IDENTIFIED);
29428 break;
29429 case IN:
29430 jj_consume_token(IN);
29431 break;
29432 case INDEX:
29433 jj_consume_token(INDEX);
29434 break;
29435 case INSERT:
29436 jj_consume_token(INSERT);
29437 break;
29438 case INTEGER:
29439 jj_consume_token(INTEGER);
29440 break;
29441 case INTERSECT:
29442 jj_consume_token(INTERSECT);
29443 break;
29444 case INTO:
29445 jj_consume_token(INTO);
29446 break;
29447 case IS:
29448 jj_consume_token(IS);
29449 break;
29450 case LIKE:
29451 jj_consume_token(LIKE);
29452 break;
29453 case LOCK:
29454 jj_consume_token(LOCK);
29455 break;
29456 case LONG:
29457 jj_consume_token(LONG);
29458 break;
29459 case MINUS:
29460 jj_consume_token(MINUS);
29461 break;
29462 case MODE:
29463 jj_consume_token(MODE);
29464 break;
29465 case NOCOMPRESS:
29466 jj_consume_token(NOCOMPRESS);
29467 break;
29468 case NOT:
29469 jj_consume_token(NOT);
29470 break;
29471 case NOWAIT:
29472 jj_consume_token(NOWAIT);
29473 break;
29474 case NULL:
29475 jj_consume_token(NULL);
29476 break;
29477 case NUMBER:
29478 jj_consume_token(NUMBER);
29479 break;
29480 case OF:
29481 jj_consume_token(OF);
29482 break;
29483 case ON:
29484 jj_consume_token(ON);
29485 break;
29486 case OPTION:
29487 jj_consume_token(OPTION);
29488 break;
29489 case OR:
29490 jj_consume_token(OR);
29491 break;
29492 case ORDER:
29493 jj_consume_token(ORDER);
29494 break;
29495 case PCTFREE:
29496 jj_consume_token(PCTFREE);
29497 break;
29498 case PRIOR:
29499 jj_consume_token(PRIOR);
29500 break;
29501 case PUBLIC:
29502 jj_consume_token(PUBLIC);
29503 break;
29504 case RAW:
29505 jj_consume_token(RAW);
29506 break;
29507 case RESOURCE:
29508 jj_consume_token(RESOURCE);
29509 break;
29510 case REVOKE:
29511 jj_consume_token(REVOKE);
29512 break;
29513 case SELECT:
29514 jj_consume_token(SELECT);
29515 break;
29516 case SET:
29517 jj_consume_token(SET);
29518 break;
29519 case SHARE:
29520 jj_consume_token(SHARE);
29521 break;
29522 case SIZE:
29523 jj_consume_token(SIZE);
29524 break;
29525 case SMALLINT:
29526 jj_consume_token(SMALLINT);
29527 break;
29528 case START:
29529 jj_consume_token(START);
29530 break;
29531 case SYNONYM:
29532 jj_consume_token(SYNONYM);
29533 break;
29534 case TABLE:
29535 jj_consume_token(TABLE);
29536 break;
29537 case THEN:
29538 jj_consume_token(THEN);
29539 break;
29540 case TO:
29541 jj_consume_token(TO);
29542 break;
29543 case TRIGGER:
29544 jj_consume_token(TRIGGER);
29545 break;
29546 case UNION:
29547 jj_consume_token(UNION);
29548 break;
29549 case UNIQUE:
29550 jj_consume_token(UNIQUE);
29551 break;
29552 case UPDATE:
29553 jj_consume_token(UPDATE);
29554 break;
29555 case VALUES:
29556 jj_consume_token(VALUES);
29557 break;
29558 case VARCHAR:
29559 jj_consume_token(VARCHAR);
29560 break;
29561 case VARCHAR2:
29562 jj_consume_token(VARCHAR2);
29563 break;
29564 case VIEW:
29565 jj_consume_token(VIEW);
29566 break;
29567 case WHERE:
29568 jj_consume_token(WHERE);
29569 break;
29570 case WITH:
29571 jj_consume_token(WITH);
29572 break;
29573 default:
29574 jj_la1[440] = jj_gen;
29575 jj_consume_token(-1);
29576 throw new ParseException();
29577 }
29578 jjtree.closeNodeScope(jjtn000, true);
29579 jjtc000 = false;
29580 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
29581 } finally {
29582 if (jjtc000) {
29583 jjtree.closeNodeScope(jjtn000, true);
29584 }
29585 }
29586 throw new Error("Missing return statement in function");
29587 }
29588
29589 final public ASTKEYWORD_UNRESERVED KEYWORD_UNRESERVED() throws ParseException {
29590
29591 ASTKEYWORD_UNRESERVED jjtn000 = new ASTKEYWORD_UNRESERVED(this, JJTKEYWORD_UNRESERVED);
29592 boolean jjtc000 = true;
29593 jjtree.openNodeScope(jjtn000);
29594 try {
29595 switch (jj_nt.kind) {
29596 case FALSE:
29597 jj_consume_token(FALSE);
29598 break;
29599 case TRUE:
29600 jj_consume_token(TRUE);
29601 break;
29602 case A:
29603 jj_consume_token(A);
29604 break;
29605 case ACCEPT:
29606 jj_consume_token(ACCEPT);
29607 break;
29608 case ADD:
29609 jj_consume_token(ADD);
29610 break;
29611 case AFTER:
29612 jj_consume_token(AFTER);
29613 break;
29614 case AGGREGATE:
29615 jj_consume_token(AGGREGATE);
29616 break;
29617 case ANALYZE:
29618 jj_consume_token(ANALYZE);
29619 break;
29620 case ASSOCIATE:
29621 jj_consume_token(ASSOCIATE);
29622 break;
29623 case AT:
29624 jj_consume_token(AT);
29625 break;
29626 case ATTACH:
29627 jj_consume_token(ATTACH);
29628 break;
29629 case ATTRIBUTE:
29630 jj_consume_token(ATTRIBUTE);
29631 break;
29632 case AUDIT:
29633 jj_consume_token(AUDIT);
29634 break;
29635 case AUTHENTICATED:
29636 jj_consume_token(AUTHENTICATED);
29637 break;
29638 case AUTHID:
29639 jj_consume_token(AUTHID);
29640 break;
29641 case BEFORE:
29642 jj_consume_token(BEFORE);
29643 break;
29644 case BFILE:
29645 jj_consume_token(BFILE);
29646 break;
29647 case BLOB:
29648 jj_consume_token(BLOB);
29649 break;
29650 case BOTH:
29651 jj_consume_token(BOTH);
29652 break;
29653 case BULK:
29654 jj_consume_token(BULK);
29655 break;
29656 case BYTE:
29657 jj_consume_token(BYTE);
29658 break;
29659 case CALL:
29660 jj_consume_token(CALL);
29661 break;
29662 case CASCADE:
29663 jj_consume_token(CASCADE);
29664 break;
29665 case CAST:
29666 jj_consume_token(CAST);
29667 break;
29668 case CHAR_CS:
29669 jj_consume_token(CHAR_CS);
29670 break;
29671 case CHARACTER:
29672 jj_consume_token(CHARACTER);
29673 break;
29674 case CHARSETFORM:
29675 jj_consume_token(CHARSETFORM);
29676 break;
29677 case CHARSETID:
29678 jj_consume_token(CHARSETID);
29679 break;
29680 case CLOB:
29681 jj_consume_token(CLOB);
29682 break;
29683 case CLOSE:
29684 jj_consume_token(CLOSE);
29685 break;
29686 case COALESCE:
29687 jj_consume_token(COALESCE);
29688 break;
29689 case COLLECT:
29690 jj_consume_token(COLLECT);
29691 break;
29692 case COLUMN:
29693 jj_consume_token(COLUMN);
29694 break;
29695 case COMMENT:
29696 jj_consume_token(COMMENT);
29697 break;
29698 case COMMIT:
29699 jj_consume_token(COMMIT);
29700 break;
29701 case COMPOUND:
29702 jj_consume_token(COMPOUND);
29703 break;
29704 case CONSTRUCTOR:
29705 jj_consume_token(CONSTRUCTOR);
29706 break;
29707 case CONTEXT:
29708 jj_consume_token(CONTEXT);
29709 break;
29710 case CONTINUE:
29711 jj_consume_token(CONTINUE);
29712 break;
29713 case CONVERT:
29714 jj_consume_token(CONVERT);
29715 break;
29716 case COPY:
29717 jj_consume_token(COPY);
29718 break;
29719 case CURRENT:
29720 jj_consume_token(CURRENT);
29721 break;
29722 case CURRENT_USER:
29723 jj_consume_token(CURRENT_USER);
29724 break;
29725 case CURSOR:
29726 jj_consume_token(CURSOR);
29727 break;
29728 case DATA:
29729 jj_consume_token(DATA);
29730 break;
29731 case DATABASE:
29732 jj_consume_token(DATABASE);
29733 break;
29734 case DAY:
29735 jj_consume_token(DAY);
29736 break;
29737 case DBTIMEZONE:
29738 jj_consume_token(DBTIMEZONE);
29739 break;
29740 case DDL:
29741 jj_consume_token(DDL);
29742 break;
29743 case DEC:
29744 jj_consume_token(DEC);
29745 break;
29746 case DEFINE:
29747 jj_consume_token(DEFINE);
29748 break;
29749 case DEFINER:
29750 jj_consume_token(DEFINER);
29751 break;
29752 case DIRECTORY:
29753 jj_consume_token(DIRECTORY);
29754 break;
29755 case DISABLE:
29756 jj_consume_token(DISABLE);
29757 break;
29758 case DISASSOCIATE:
29759 jj_consume_token(DISASSOCIATE);
29760 break;
29761 case DISCONNECT:
29762 jj_consume_token(DISCONNECT);
29763 break;
29764 case DOUBLE:
29765 jj_consume_token(DOUBLE);
29766 break;
29767 case EACH:
29768 jj_consume_token(EACH);
29769 break;
29770 case ELEMENT:
29771 jj_consume_token(ELEMENT);
29772 break;
29773 case EMPTY:
29774 jj_consume_token(EMPTY);
29775 break;
29776 case ENABLE:
29777 jj_consume_token(ENABLE);
29778 break;
29779 case ESCAPE:
29780 jj_consume_token(ESCAPE);
29781 break;
29782 case EXCEPT:
29783 jj_consume_token(EXCEPT);
29784 break;
29785 case EXCEPTIONS:
29786 jj_consume_token(EXCEPTIONS);
29787 break;
29788 case EXIT:
29789 jj_consume_token(EXIT);
29790 break;
29791 case EXTENDS:
29792 jj_consume_token(EXTENDS);
29793 break;
29794 case EXTERNAL:
29795 jj_consume_token(EXTERNAL);
29796 break;
29797 case EXTRACT:
29798 jj_consume_token(EXTRACT);
29799 break;
29800 case FINAL:
29801 jj_consume_token(FINAL);
29802 break;
29803 case FOLLOWS:
29804 jj_consume_token(FOLLOWS);
29805 break;
29806 case FORCE:
29807 jj_consume_token(FORCE);
29808 break;
29809 case FUNCTION:
29810 jj_consume_token(FUNCTION);
29811 break;
29812 case GLOBAL:
29813 jj_consume_token(GLOBAL);
29814 break;
29815 case HASH:
29816 jj_consume_token(HASH);
29817 break;
29818 case HEAP:
29819 jj_consume_token(HEAP);
29820 break;
29821 case HOST:
29822 jj_consume_token(HOST);
29823 break;
29824 case HOUR:
29825 jj_consume_token(HOUR);
29826 break;
29827 case IMMEDIATE:
29828 jj_consume_token(IMMEDIATE);
29829 break;
29830 case INDEXTYPE:
29831 jj_consume_token(INDEXTYPE);
29832 break;
29833 case INDICATOR:
29834 jj_consume_token(INDICATOR);
29835 break;
29836 case INDICES:
29837 jj_consume_token(INDICES);
29838 break;
29839 case INSTANTIABLE:
29840 jj_consume_token(INSTANTIABLE);
29841 break;
29842 case INTERVAL:
29843 jj_consume_token(INTERVAL);
29844 break;
29845 case INVALIDATE:
29846 jj_consume_token(INVALIDATE);
29847 break;
29848 case ISOLATION:
29849 jj_consume_token(ISOLATION);
29850 break;
29851 case JAVA:
29852 jj_consume_token(JAVA);
29853 break;
29854 case LANGUAGE:
29855 jj_consume_token(LANGUAGE);
29856 break;
29857 case LEADING:
29858 jj_consume_token(LEADING);
29859 break;
29860 case LEFT:
29861 jj_consume_token(LEFT);
29862 break;
29863 case LENGTH:
29864 jj_consume_token(LENGTH);
29865 break;
29866 case LEVEL:
29867 jj_consume_token(LEVEL);
29868 break;
29869 case LIBRARY:
29870 jj_consume_token(LIBRARY);
29871 break;
29872 case LIMIT:
29873 jj_consume_token(LIMIT);
29874 break;
29875 case LINK:
29876 jj_consume_token(LINK);
29877 break;
29878 case LOCAL:
29879 jj_consume_token(LOCAL);
29880 break;
29881 case LOGOFF:
29882 jj_consume_token(LOGOFF);
29883 break;
29884 case LOGON:
29885 jj_consume_token(LOGON);
29886 break;
29887 case MAP:
29888 jj_consume_token(MAP);
29889 break;
29890 case MAX:
29891 jj_consume_token(MAX);
29892 break;
29893 case MAXLEN:
29894 jj_consume_token(MAXLEN);
29895 break;
29896 case MEMBER:
29897 jj_consume_token(MEMBER);
29898 break;
29899 case MERGE:
29900 jj_consume_token(MERGE);
29901 break;
29902 case MIN:
29903 jj_consume_token(MIN);
29904 break;
29905 case MINUTE:
29906 jj_consume_token(MINUTE);
29907 break;
29908 case MLSLABEL:
29909 jj_consume_token(MLSLABEL);
29910 break;
29911 case MODIFY:
29912 jj_consume_token(MODIFY);
29913 break;
29914 case MONTH:
29915 jj_consume_token(MONTH);
29916 break;
29917 case MULTISET:
29918 jj_consume_token(MULTISET);
29919 break;
29920 case NAME:
29921 jj_consume_token(NAME);
29922 break;
29923 case NATURAL:
29924 jj_consume_token(NATURAL);
29925 break;
29926 case NCHAR:
29927 jj_consume_token(NCHAR);
29928 break;
29929 case NCHAR_CS:
29930 jj_consume_token(NCHAR_CS);
29931 break;
29932 case NCLOB:
29933 jj_consume_token(NCLOB);
29934 break;
29935 case NESTED:
29936 jj_consume_token(NESTED);
29937 break;
29938 case NEW:
29939 jj_consume_token(NEW);
29940 break;
29941 case NO:
29942 jj_consume_token(NO);
29943 break;
29944 case NOAUDIT:
29945 jj_consume_token(NOAUDIT);
29946 break;
29947 case NUMERIC:
29948 jj_consume_token(NUMERIC);
29949 break;
29950 case NVARCHAR2:
29951 jj_consume_token(NVARCHAR2);
29952 break;
29953 case OBJECT:
29954 jj_consume_token(OBJECT);
29955 break;
29956 case OID:
29957 jj_consume_token(OID);
29958 break;
29959 case OLD:
29960 jj_consume_token(OLD);
29961 break;
29962 case OPAQUE:
29963 jj_consume_token(OPAQUE);
29964 break;
29965 case OPEN:
29966 jj_consume_token(OPEN);
29967 break;
29968 case ORGANIZATION:
29969 jj_consume_token(ORGANIZATION);
29970 break;
29971 case OTHERS:
29972 jj_consume_token(OTHERS);
29973 break;
29974 case OVERRIDING:
29975 jj_consume_token(OVERRIDING);
29976 break;
29977 case PACKAGE:
29978 jj_consume_token(PACKAGE);
29979 break;
29980 case PARAMETERS:
29981 jj_consume_token(PARAMETERS);
29982 break;
29983 case PARENT:
29984 jj_consume_token(PARENT);
29985 break;
29986 case PARTITION:
29987 jj_consume_token(PARTITION);
29988 break;
29989 case PRECISION:
29990 jj_consume_token(PRECISION);
29991 break;
29992 case PRESERVE:
29993 jj_consume_token(PRESERVE);
29994 break;
29995 case PRINT:
29996 jj_consume_token(PRINT);
29997 break;
29998 case PROCEDURE:
29999 jj_consume_token(PROCEDURE);
30000 break;
30001 case QUIT:
30002 jj_consume_token(QUIT);
30003 break;
30004 case RANGE:
30005 jj_consume_token(RANGE);
30006 break;
30007 case REAL:
30008 jj_consume_token(REAL);
30009 break;
30010 case RECORD:
30011 jj_consume_token(RECORD);
30012 break;
30013 case REF:
30014 jj_consume_token(REF);
30015 break;
30016 case RELIES_ON:
30017 jj_consume_token(RELIES_ON);
30018 break;
30019 case REMARK:
30020 jj_consume_token(REMARK);
30021 break;
30022 case RESULT:
30023 jj_consume_token(RESULT);
30024 break;
30025 case RETURN:
30026 jj_consume_token(RETURN);
30027 break;
30028 case RETURNING:
30029 jj_consume_token(RETURNING);
30030 break;
30031 case REVERSE:
30032 jj_consume_token(REVERSE);
30033 break;
30034 case RIGHT:
30035 jj_consume_token(RIGHT);
30036 break;
30037 case ROLLBACK:
30038 jj_consume_token(ROLLBACK);
30039 break;
30040 case ROW:
30041 jj_consume_token(ROW);
30042 break;
30043 case ROWID:
30044 jj_consume_token(ROWID);
30045 break;
30046 case ROWNUM:
30047 jj_consume_token(ROWNUM);
30048 break;
30049 case ROWS:
30050 jj_consume_token(ROWS);
30051 break;
30052 case SAVE:
30053 jj_consume_token(SAVE);
30054 break;
30055 case SAVEPOINT:
30056 jj_consume_token(SAVEPOINT);
30057 break;
30058 case SCHEMA:
30059 jj_consume_token(SCHEMA);
30060 break;
30061 case SECOND:
30062 jj_consume_token(SECOND);
30063 break;
30064 case SELF:
30065 jj_consume_token(SELF);
30066 break;
30067 case SERVERERROR:
30068 jj_consume_token(SERVERERROR);
30069 break;
30070 case SESSIONTIMEZONE:
30071 jj_consume_token(SESSIONTIMEZONE);
30072 break;
30073 case SET:
30074 jj_consume_token(SET);
30075 break;
30076 case SHARED:
30077 jj_consume_token(SHARED);
30078 break;
30079 case SHUTDOWN:
30080 jj_consume_token(SHUTDOWN);
30081 break;
30082 case SPACE:
30083 jj_consume_token(SPACE);
30084 break;
30085 case STARTUP:
30086 jj_consume_token(STARTUP);
30087 break;
30088 case STATEMENT:
30089 jj_consume_token(STATEMENT);
30090 break;
30091 case STATIC:
30092 jj_consume_token(STATIC);
30093 break;
30094 case STATISTICS:
30095 jj_consume_token(STATISTICS);
30096 break;
30097 case STRUCT:
30098 jj_consume_token(STRUCT);
30099 break;
30100 case SUBMULTISET:
30101 jj_consume_token(SUBMULTISET);
30102 break;
30103 case SUBSTITUTABLE:
30104 jj_consume_token(SUBSTITUTABLE);
30105 break;
30106 case SUBTYPE:
30107 jj_consume_token(SUBTYPE);
30108 break;
30109 case SUCCESSFUL:
30110 jj_consume_token(SUCCESSFUL);
30111 break;
30112 case SUSPEND:
30113 jj_consume_token(SUSPEND);
30114 break;
30115 case TDO:
30116 jj_consume_token(TDO);
30117 break;
30118 case TEMPORARY:
30119 jj_consume_token(TEMPORARY);
30120 break;
30121 case TIME:
30122 jj_consume_token(TIME);
30123 break;
30124 case TIMESTAMP:
30125 jj_consume_token(TIMESTAMP);
30126 break;
30127 case TIMEZONE_ABBR:
30128 jj_consume_token(TIMEZONE_ABBR);
30129 break;
30130 case TIMEZONE_HOUR:
30131 jj_consume_token(TIMEZONE_HOUR);
30132 break;
30133 case TIMEZONE_MINUTE:
30134 jj_consume_token(TIMEZONE_MINUTE);
30135 break;
30136 case TIMEZONE_REGION:
30137 jj_consume_token(TIMEZONE_REGION);
30138 break;
30139 case TRAILING:
30140 jj_consume_token(TRAILING);
30141 break;
30142 case TRANSACTION:
30143 jj_consume_token(TRANSACTION);
30144 break;
30145 case TREAT:
30146 jj_consume_token(TREAT);
30147 break;
30148 case TRIM:
30149 jj_consume_token(TRIM);
30150 break;
30151 case TRUNCATE:
30152 jj_consume_token(TRUNCATE);
30153 break;
30154 case UNDEFINE:
30155 jj_consume_token(UNDEFINE);
30156 break;
30157 case UNDER:
30158 jj_consume_token(UNDER);
30159 break;
30160 case UROWID:
30161 jj_consume_token(UROWID);
30162 break;
30163 case USER:
30164 jj_consume_token(USER);
30165 break;
30166 case USING:
30167 jj_consume_token(USING);
30168 break;
30169 case VARRAY:
30170 jj_consume_token(VARRAY);
30171 break;
30172 case VARIABLE:
30173 jj_consume_token(VARIABLE);
30174 break;
30175 case VARYING:
30176 jj_consume_token(VARYING);
30177 break;
30178 case WHENEVER:
30179 jj_consume_token(WHENEVER);
30180 break;
30181 case YEAR:
30182 jj_consume_token(YEAR);
30183 break;
30184 case YES:
30185 jj_consume_token(YES);
30186 break;
30187 case ZONE:
30188 jj_consume_token(ZONE);
30189 break;
30190 case SHOW:
30191 jj_consume_token(SHOW);
30192 break;
30193 case WRAPPED:
30194 jj_consume_token(WRAPPED);
30195 break;
30196 case SYS_REFCURSOR:
30197 jj_consume_token(SYS_REFCURSOR);
30198 break;
30199 case EDITIONABLE:
30200 jj_consume_token(EDITIONABLE);
30201 break;
30202 case NONEDITIONABLE:
30203 jj_consume_token(NONEDITIONABLE);
30204 break;
30205 case ACCESSIBLE:
30206 jj_consume_token(ACCESSIBLE);
30207 break;
30208 case NULLIF:
30209 jj_consume_token(NULLIF);
30210 break;
30211 case RENAME:
30212 jj_consume_token(RENAME);
30213 break;
30214 case RELEASE:
30215 jj_consume_token(RELEASE);
30216 break;
30217 default:
30218 jj_la1[441] = jj_gen;
30219 jj_consume_token(-1);
30220 throw new ParseException();
30221 }
30222 jjtree.closeNodeScope(jjtn000, true);
30223 jjtc000 = false;
30224 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30225 } finally {
30226 if (jjtc000) {
30227 jjtree.closeNodeScope(jjtn000, true);
30228 }
30229 }
30230 throw new Error("Missing return statement in function");
30231 }
30232
30233
30234
30235
30236
30237 final public ASTID ID() throws ParseException {
30238
30239 ASTID jjtn000 = new ASTID(this, JJTID);
30240 boolean jjtc000 = true;
30241 jjtree.openNodeScope(jjtn000);
30242 try {
30243 switch (jj_nt.kind) {
30244 case IDENTIFIER:
30245 jj_consume_token(IDENTIFIER);
30246 break;
30247 case QUOTED_LITERAL:
30248 jj_consume_token(QUOTED_LITERAL);
30249 break;
30250 case DEFINER:
30251 case CURRENT_USER:
30252 case LANGUAGE:
30253 case ADD:
30254 case AGGREGATE:
30255 case AT:
30256 case ATTRIBUTE:
30257 case AUTHID:
30258 case BULK:
30259 case BYTE:
30260 case CASCADE:
30261 case CLOSE:
30262 case COALESCE:
30263 case COLLECT:
30264 case COLUMN:
30265 case COMMENT:
30266 case COMMIT:
30267 case CONSTRUCTOR:
30268 case CONTINUE:
30269 case CONVERT:
30270 case CURRENT:
30271 case CURSOR:
30272 case DATA:
30273 case DAY:
30274 case DISABLE:
30275 case EDITIONABLE:
30276 case ELEMENT:
30277 case ENABLE:
30278 case ESCAPE:
30279 case EXCEPT:
30280 case EXCEPTIONS:
30281 case EXIT:
30282 case EXTERNAL:
30283 case EXTENDS:
30284 case EXTRACT:
30285 case FALSE:
30286 case FINAL:
30287 case FORCE:
30288 case FUNCTION:
30289 case GLOBAL:
30290 case HASH:
30291 case HEAP:
30292 case HOUR:
30293 case IMMEDIATE:
30294 case INDICES:
30295 case INDEXTYPE:
30296 case INDICATOR:
30297 case INSTANTIABLE:
30298 case INTERVAL:
30299 case INVALIDATE:
30300 case ISOLATION:
30301 case JAVA:
30302 case LEVEL:
30303 case LIMIT:
30304 case MAP:
30305 case MAX:
30306 case MEMBER:
30307 case MERGE:
30308 case MIN:
30309 case MINUTE:
30310 case MLSLABEL:
30311 case MODIFY:
30312 case MONTH:
30313 case NATURAL:
30314 case NEW:
30315 case NO:
30316 case NONEDITIONABLE:
30317 case NULLIF:
30318 case OBJECT:
30319 case OID:
30320 case OPAQUE:
30321 case OPEN:
30322 case ORGANIZATION:
30323 case OTHERS:
30324 case OVERRIDING:
30325 case PACKAGE:
30326 case PARTITION:
30327 case PRESERVE:
30328 case PROCEDURE:
30329 case RANGE:
30330 case REAL:
30331 case RECORD:
30332 case REF:
30333 case RELEASE:
30334 case RELIES_ON:
30335 case RENAME:
30336 case RESULT:
30337 case RETURN:
30338 case RETURNING:
30339 case REVERSE:
30340 case ROLLBACK:
30341 case ROW:
30342 case ROWS:
30343 case ROWID:
30344 case ROWNUM:
30345 case SAVE:
30346 case SAVEPOINT:
30347 case SECOND:
30348 case SELF:
30349 case SET:
30350 case SPACE:
30351 case STATIC:
30352 case SUBTYPE:
30353 case SUBSTITUTABLE:
30354 case SUCCESSFUL:
30355 case SYS_REFCURSOR:
30356 case TEMPORARY:
30357 case TIME:
30358 case TIMESTAMP:
30359 case TIMEZONE_REGION:
30360 case TIMEZONE_ABBR:
30361 case TIMEZONE_MINUTE:
30362 case TIMEZONE_HOUR:
30363 case TRANSACTION:
30364 case TRUE:
30365 case UNDER:
30366 case USING:
30367 case YES:
30368 case SHOW:
30369 case A:
30370 case DOUBLE:
30371 case DEC:
30372 case PRECISION:
30373 case NUMERIC:
30374 case NCHAR:
30375 case NVARCHAR2:
30376 case UROWID:
30377 case VARRAY:
30378 case VARYING:
30379 case BFILE:
30380 case BLOB:
30381 case CLOB:
30382 case NCLOB:
30383 case YEAR:
30384 case LOCAL:
30385 case ZONE:
30386 case CHARACTER:
30387 case AFTER:
30388 case BEFORE:
30389 case OLD:
30390 case PARENT:
30391 case ANALYZE:
30392 case ASSOCIATE:
30393 case AUDIT:
30394 case COMPOUND:
30395 case DATABASE:
30396 case CALL:
30397 case DDL:
30398 case DISASSOCIATE:
30399 case EACH:
30400 case FOLLOWS:
30401 case LOGOFF:
30402 case LOGON:
30403 case NESTED:
30404 case NOAUDIT:
30405 case SCHEMA:
30406 case SERVERERROR:
30407 case SHUTDOWN:
30408 case STARTUP:
30409 case STATEMENT:
30410 case STATISTICS:
30411 case SUSPEND:
30412 case TRUNCATE:
30413 case WRAPPED:
30414 case LIBRARY:
30415 case NAME:
30416 case STRUCT:
30417 case CONTEXT:
30418 case PARAMETERS:
30419 case LENGTH:
30420 case TDO:
30421 case MAXLEN:
30422 case CHARSETID:
30423 case CHARSETFORM:
30424 case ACCEPT:
30425 case ACCESSIBLE:
30426 case COPY:
30427 case DEFINE:
30428 case DISCONNECT:
30429 case HOST:
30430 case PRINT:
30431 case QUIT:
30432 case REMARK:
30433 case UNDEFINE:
30434 case VARIABLE:
30435 case WHENEVER:
30436 case ATTACH:
30437 case CAST:
30438 case TREAT:
30439 case TRIM:
30440 case LEFT:
30441 case RIGHT:
30442 case BOTH:
30443 case EMPTY:
30444 case MULTISET:
30445 case SUBMULTISET:
30446 case LEADING:
30447 case TRAILING:
30448 case CHAR_CS:
30449 case NCHAR_CS:
30450 case DBTIMEZONE:
30451 case SESSIONTIMEZONE:
30452 case AUTHENTICATED:
30453 case LINK:
30454 case SHARED:
30455 case DIRECTORY:
30456 case USER:
30457 KEYWORD_UNRESERVED();
30458 break;
30459 case REPLACE:
30460 jj_consume_token(REPLACE);
30461 break;
30462 case SERIALLY_REUSABLE:
30463 jj_consume_token(SERIALLY_REUSABLE);
30464 break;
30465 case RESTRICT_REFERENCES:
30466 jj_consume_token(RESTRICT_REFERENCES);
30467 break;
30468 case EXCEPTION_INIT:
30469 jj_consume_token(EXCEPTION_INIT);
30470 break;
30471 case AUTONOMOUS_TRANSACTION:
30472 jj_consume_token(AUTONOMOUS_TRANSACTION);
30473 break;
30474 case ALL:
30475 jj_consume_token(ALL);
30476 break;
30477 case ALTER:
30478 jj_consume_token(ALTER);
30479 break;
30480 case AND:
30481 jj_consume_token(AND);
30482 break;
30483 case ANY:
30484 jj_consume_token(ANY);
30485 break;
30486 case ARRAY:
30487 jj_consume_token(ARRAY);
30488 break;
30489 case AS:
30490 jj_consume_token(AS);
30491 break;
30492 case ASC:
30493 jj_consume_token(ASC);
30494 break;
30495 case AVG:
30496 jj_consume_token(AVG);
30497 break;
30498 case BETWEEN:
30499 jj_consume_token(BETWEEN);
30500 break;
30501 case BINARY_INTEGER:
30502 jj_consume_token(BINARY_INTEGER);
30503 break;
30504 case BODY:
30505 jj_consume_token(BODY);
30506 break;
30507 case BOOLEAN:
30508 jj_consume_token(BOOLEAN);
30509 break;
30510 case BY:
30511 jj_consume_token(BY);
30512 break;
30513 case CASE:
30514 jj_consume_token(CASE);
30515 break;
30516 case CHAR:
30517 jj_consume_token(CHAR);
30518 break;
30519 case CHAR_BASE:
30520 jj_consume_token(CHAR_BASE);
30521 break;
30522 case CHECK:
30523 jj_consume_token(CHECK);
30524 break;
30525 case CLUSTER:
30526 jj_consume_token(CLUSTER);
30527 break;
30528 case COMPRESS:
30529 jj_consume_token(COMPRESS);
30530 break;
30531 case CONNECT:
30532 jj_consume_token(CONNECT);
30533 break;
30534 case CONSTANT:
30535 jj_consume_token(CONSTANT);
30536 break;
30537 case CREATE:
30538 jj_consume_token(CREATE);
30539 break;
30540 case CURRVAL:
30541 jj_consume_token(CURRVAL);
30542 break;
30543 case DATE:
30544 jj_consume_token(DATE);
30545 break;
30546 case DECLARE:
30547 jj_consume_token(DECLARE);
30548 break;
30549 case DECIMAL:
30550 jj_consume_token(DECIMAL);
30551 break;
30552 case _DEFAULT:
30553 jj_consume_token(_DEFAULT);
30554 break;
30555 case DELETE:
30556 jj_consume_token(DELETE);
30557 break;
30558 case DESC:
30559 jj_consume_token(DESC);
30560 break;
30561 case DISTINCT:
30562 jj_consume_token(DISTINCT);
30563 break;
30564 case DO:
30565 jj_consume_token(DO);
30566 break;
30567 case DROP:
30568 jj_consume_token(DROP);
30569 break;
30570 case ELSE:
30571 jj_consume_token(ELSE);
30572 break;
30573 case ELSIF:
30574 jj_consume_token(ELSIF);
30575 break;
30576 case EXCEPTION:
30577 jj_consume_token(EXCEPTION);
30578 break;
30579 case EXCLUSIVE:
30580 jj_consume_token(EXCLUSIVE);
30581 break;
30582 case EXECUTE:
30583 jj_consume_token(EXECUTE);
30584 break;
30585 case EXISTS:
30586 jj_consume_token(EXISTS);
30587 break;
30588 case FETCH:
30589 jj_consume_token(FETCH);
30590 break;
30591 case FLOAT:
30592 jj_consume_token(FLOAT);
30593 break;
30594 case FOR:
30595 jj_consume_token(FOR);
30596 break;
30597 case FORALL:
30598 jj_consume_token(FORALL);
30599 break;
30600 case FROM:
30601 jj_consume_token(FROM);
30602 break;
30603 case GOTO:
30604 jj_consume_token(GOTO);
30605 break;
30606 case GROUP:
30607 jj_consume_token(GROUP);
30608 break;
30609 case HAVING:
30610 jj_consume_token(HAVING);
30611 break;
30612 case IF:
30613 jj_consume_token(IF);
30614 break;
30615 case IN:
30616 jj_consume_token(IN);
30617 break;
30618 case INDEX:
30619 jj_consume_token(INDEX);
30620 break;
30621 case INSERT:
30622 jj_consume_token(INSERT);
30623 break;
30624 case INTEGER:
30625 jj_consume_token(INTEGER);
30626 break;
30627 case INTERFACE:
30628 jj_consume_token(INTERFACE);
30629 break;
30630 case INTERSECT:
30631 jj_consume_token(INTERSECT);
30632 break;
30633 case INTO:
30634 jj_consume_token(INTO);
30635 break;
30636 case IS:
30637 jj_consume_token(IS);
30638 break;
30639 case LIKE:
30640 jj_consume_token(LIKE);
30641 break;
30642 case LIMITED:
30643 jj_consume_token(LIMITED);
30644 break;
30645 case LOCK:
30646 jj_consume_token(LOCK);
30647 break;
30648 case LONG:
30649 jj_consume_token(LONG);
30650 break;
30651 case LOOP:
30652 jj_consume_token(LOOP);
30653 break;
30654 case MINUS:
30655 jj_consume_token(MINUS);
30656 break;
30657 case MOD:
30658 jj_consume_token(MOD);
30659 break;
30660 case MODE:
30661 jj_consume_token(MODE);
30662 break;
30663 case NATURALN:
30664 jj_consume_token(NATURALN);
30665 break;
30666 case NEXTVAL:
30667 jj_consume_token(NEXTVAL);
30668 break;
30669 case NOCOPY:
30670 jj_consume_token(NOCOPY);
30671 break;
30672 case NOT:
30673 jj_consume_token(NOT);
30674 break;
30675 case NOWAIT:
30676 jj_consume_token(NOWAIT);
30677 break;
30678 case NULL:
30679 jj_consume_token(NULL);
30680 break;
30681 case NUMBER:
30682 jj_consume_token(NUMBER);
30683 break;
30684 case NUMBER_BASE:
30685 jj_consume_token(NUMBER_BASE);
30686 break;
30687 case OCIROWID:
30688 jj_consume_token(OCIROWID);
30689 break;
30690 case OF:
30691 jj_consume_token(OF);
30692 break;
30693 case ON:
30694 jj_consume_token(ON);
30695 break;
30696 case BFILE_BASE:
30697 jj_consume_token(BFILE_BASE);
30698 break;
30699 case BLOB_BASE:
30700 jj_consume_token(BLOB_BASE);
30701 break;
30702 case CLOB_BASE:
30703 jj_consume_token(CLOB_BASE);
30704 break;
30705 case DATE_BASE:
30706 jj_consume_token(DATE_BASE);
30707 break;
30708 case OPERATOR:
30709 jj_consume_token(OPERATOR);
30710 break;
30711 case OPTION:
30712 jj_consume_token(OPTION);
30713 break;
30714 case OR:
30715 jj_consume_token(OR);
30716 break;
30717 case ORDER:
30718 jj_consume_token(ORDER);
30719 break;
30720 case OUT:
30721 jj_consume_token(OUT);
30722 break;
30723 case PCTFREE:
30724 jj_consume_token(PCTFREE);
30725 break;
30726 case PLS_INTEGER:
30727 jj_consume_token(PLS_INTEGER);
30728 break;
30729 case POSITIVE:
30730 jj_consume_token(POSITIVE);
30731 break;
30732 case POSITIVEN:
30733 jj_consume_token(POSITIVEN);
30734 break;
30735 case PRIOR:
30736 jj_consume_token(PRIOR);
30737 break;
30738 case PRIVATE:
30739 jj_consume_token(PRIVATE);
30740 break;
30741 case PROMPT:
30742 jj_consume_token(PROMPT);
30743 break;
30744 case PUBLIC:
30745 jj_consume_token(PUBLIC);
30746 break;
30747 case RAISE:
30748 jj_consume_token(RAISE);
30749 break;
30750 case RAW:
30751 jj_consume_token(RAW);
30752 break;
30753 case ROWTYPE:
30754 jj_consume_token(ROWTYPE);
30755 break;
30756 case SELECT:
30757 jj_consume_token(SELECT);
30758 break;
30759 case SEPARATE:
30760 jj_consume_token(SEPARATE);
30761 break;
30762 case SHARE:
30763 jj_consume_token(SHARE);
30764 break;
30765 case SMALLINT:
30766 jj_consume_token(SMALLINT);
30767 break;
30768 case SQL:
30769 jj_consume_token(SQL);
30770 break;
30771 case SQLCODE:
30772 jj_consume_token(SQLCODE);
30773 break;
30774 case SQLERRM:
30775 jj_consume_token(SQLERRM);
30776 break;
30777 case START:
30778 jj_consume_token(START);
30779 break;
30780 case STDDEV:
30781 jj_consume_token(STDDEV);
30782 break;
30783 case SUM:
30784 jj_consume_token(SUM);
30785 break;
30786 case SYNONYM:
30787 jj_consume_token(SYNONYM);
30788 break;
30789 case SYSDATE:
30790 jj_consume_token(SYSDATE);
30791 break;
30792 case TABLE:
30793 jj_consume_token(TABLE);
30794 break;
30795 case THEN:
30796 jj_consume_token(THEN);
30797 break;
30798 case TO:
30799 jj_consume_token(TO);
30800 break;
30801 case TRIGGER:
30802 jj_consume_token(TRIGGER);
30803 break;
30804 case TYPE:
30805 jj_consume_token(TYPE);
30806 break;
30807 case UI:
30808 jj_consume_token(UI);
30809 break;
30810 case UPDATE:
30811 jj_consume_token(UPDATE);
30812 break;
30813 case VARCHAR:
30814 jj_consume_token(VARCHAR);
30815 break;
30816 case VARCHAR2:
30817 jj_consume_token(VARCHAR2);
30818 break;
30819 case INT:
30820 jj_consume_token(INT);
30821 break;
30822 case SIGNTYPE:
30823 jj_consume_token(SIGNTYPE);
30824 break;
30825 case STRING:
30826 jj_consume_token(STRING);
30827 break;
30828 case WITH:
30829 jj_consume_token(WITH);
30830 break;
30831 case WHILE:
30832 jj_consume_token(WHILE);
30833 break;
30834 case JAVA_INTERFACE_CLASS:
30835 jj_consume_token(JAVA_INTERFACE_CLASS);
30836 break;
30837 case SQLDATA_CLASS:
30838 jj_consume_token(SQLDATA_CLASS);
30839 break;
30840 case CUSTOMDATUM_CLASS:
30841 jj_consume_token(CUSTOMDATUM_CLASS);
30842 break;
30843 case ORADATA_CLASS:
30844 jj_consume_token(ORADATA_CLASS);
30845 break;
30846 default:
30847 jj_la1[442] = jj_gen;
30848 jj_consume_token(-1);
30849 throw new ParseException();
30850 }
30851 jjtree.closeNodeScope(jjtn000, true);
30852 jjtc000 = false;
30853 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
30854 } catch (Throwable jjte000) {
30855 if (jjtc000) {
30856 jjtree.clearNodeScope(jjtn000);
30857 jjtc000 = false;
30858 } else {
30859 jjtree.popNode();
30860 }
30861 if (jjte000 instanceof RuntimeException) {
30862 {if (true) throw (RuntimeException)jjte000;}
30863 }
30864 if (jjte000 instanceof ParseException) {
30865 {if (true) throw (ParseException)jjte000;}
30866 }
30867 {if (true) throw (Error)jjte000;}
30868 } finally {
30869 if (jjtc000) {
30870 jjtree.closeNodeScope(jjtn000, true);
30871 }
30872 }
30873 throw new Error("Missing return statement in function");
30874 }
30875
30876
30877
30878
30879 final public ASTUnqualifiedID UnqualifiedID() throws ParseException {
30880
30881 ASTUnqualifiedID jjtn000 = new ASTUnqualifiedID(this, JJTUNQUALIFIEDID);
30882 boolean jjtc000 = true;
30883 jjtree.openNodeScope(jjtn000);
30884 try {
30885 switch (jj_nt.kind) {
30886 case IDENTIFIER:
30887 jj_consume_token(IDENTIFIER);
30888 break;
30889 case QUOTED_LITERAL:
30890 jj_consume_token(QUOTED_LITERAL);
30891 break;
30892 case DEFINER:
30893 case CURRENT_USER:
30894 case LANGUAGE:
30895 case ADD:
30896 case AGGREGATE:
30897 case AT:
30898 case ATTRIBUTE:
30899 case AUTHID:
30900 case BULK:
30901 case BYTE:
30902 case CASCADE:
30903 case CLOSE:
30904 case COALESCE:
30905 case COLLECT:
30906 case COLUMN:
30907 case COMMENT:
30908 case COMMIT:
30909 case CONSTRUCTOR:
30910 case CONTINUE:
30911 case CONVERT:
30912 case CURRENT:
30913 case CURSOR:
30914 case DATA:
30915 case DAY:
30916 case DISABLE:
30917 case EDITIONABLE:
30918 case ELEMENT:
30919 case ENABLE:
30920 case ESCAPE:
30921 case EXCEPT:
30922 case EXCEPTIONS:
30923 case EXIT:
30924 case EXTERNAL:
30925 case EXTENDS:
30926 case EXTRACT:
30927 case FALSE:
30928 case FINAL:
30929 case FORCE:
30930 case FUNCTION:
30931 case GLOBAL:
30932 case HASH:
30933 case HEAP:
30934 case HOUR:
30935 case IMMEDIATE:
30936 case INDICES:
30937 case INDEXTYPE:
30938 case INDICATOR:
30939 case INSTANTIABLE:
30940 case INTERVAL:
30941 case INVALIDATE:
30942 case ISOLATION:
30943 case JAVA:
30944 case LEVEL:
30945 case LIMIT:
30946 case MAP:
30947 case MAX:
30948 case MEMBER:
30949 case MERGE:
30950 case MIN:
30951 case MINUTE:
30952 case MLSLABEL:
30953 case MODIFY:
30954 case MONTH:
30955 case NATURAL:
30956 case NEW:
30957 case NO:
30958 case NONEDITIONABLE:
30959 case NULLIF:
30960 case OBJECT:
30961 case OID:
30962 case OPAQUE:
30963 case OPEN:
30964 case ORGANIZATION:
30965 case OTHERS:
30966 case OVERRIDING:
30967 case PACKAGE:
30968 case PARTITION:
30969 case PRESERVE:
30970 case PROCEDURE:
30971 case RANGE:
30972 case REAL:
30973 case RECORD:
30974 case REF:
30975 case RELEASE:
30976 case RELIES_ON:
30977 case RENAME:
30978 case RESULT:
30979 case RETURN:
30980 case RETURNING:
30981 case REVERSE:
30982 case ROLLBACK:
30983 case ROW:
30984 case ROWS:
30985 case ROWID:
30986 case ROWNUM:
30987 case SAVE:
30988 case SAVEPOINT:
30989 case SECOND:
30990 case SELF:
30991 case SET:
30992 case SPACE:
30993 case STATIC:
30994 case SUBTYPE:
30995 case SUBSTITUTABLE:
30996 case SUCCESSFUL:
30997 case SYS_REFCURSOR:
30998 case TEMPORARY:
30999 case TIME:
31000 case TIMESTAMP:
31001 case TIMEZONE_REGION:
31002 case TIMEZONE_ABBR:
31003 case TIMEZONE_MINUTE:
31004 case TIMEZONE_HOUR:
31005 case TRANSACTION:
31006 case TRUE:
31007 case UNDER:
31008 case USING:
31009 case YES:
31010 case SHOW:
31011 case A:
31012 case DOUBLE:
31013 case DEC:
31014 case PRECISION:
31015 case NUMERIC:
31016 case NCHAR:
31017 case NVARCHAR2:
31018 case UROWID:
31019 case VARRAY:
31020 case VARYING:
31021 case BFILE:
31022 case BLOB:
31023 case CLOB:
31024 case NCLOB:
31025 case YEAR:
31026 case LOCAL:
31027 case ZONE:
31028 case CHARACTER:
31029 case AFTER:
31030 case BEFORE:
31031 case OLD:
31032 case PARENT:
31033 case ANALYZE:
31034 case ASSOCIATE:
31035 case AUDIT:
31036 case COMPOUND:
31037 case DATABASE:
31038 case CALL:
31039 case DDL:
31040 case DISASSOCIATE:
31041 case EACH:
31042 case FOLLOWS:
31043 case LOGOFF:
31044 case LOGON:
31045 case NESTED:
31046 case NOAUDIT:
31047 case SCHEMA:
31048 case SERVERERROR:
31049 case SHUTDOWN:
31050 case STARTUP:
31051 case STATEMENT:
31052 case STATISTICS:
31053 case SUSPEND:
31054 case TRUNCATE:
31055 case WRAPPED:
31056 case LIBRARY:
31057 case NAME:
31058 case STRUCT:
31059 case CONTEXT:
31060 case PARAMETERS:
31061 case LENGTH:
31062 case TDO:
31063 case MAXLEN:
31064 case CHARSETID:
31065 case CHARSETFORM:
31066 case ACCEPT:
31067 case ACCESSIBLE:
31068 case COPY:
31069 case DEFINE:
31070 case DISCONNECT:
31071 case HOST:
31072 case PRINT:
31073 case QUIT:
31074 case REMARK:
31075 case UNDEFINE:
31076 case VARIABLE:
31077 case WHENEVER:
31078 case ATTACH:
31079 case CAST:
31080 case TREAT:
31081 case TRIM:
31082 case LEFT:
31083 case RIGHT:
31084 case BOTH:
31085 case EMPTY:
31086 case MULTISET:
31087 case SUBMULTISET:
31088 case LEADING:
31089 case TRAILING:
31090 case CHAR_CS:
31091 case NCHAR_CS:
31092 case DBTIMEZONE:
31093 case SESSIONTIMEZONE:
31094 case AUTHENTICATED:
31095 case LINK:
31096 case SHARED:
31097 case DIRECTORY:
31098 case USER:
31099 KEYWORD_UNRESERVED();
31100 break;
31101 case BODY:
31102 jj_consume_token(BODY);
31103 break;
31104 case MOD:
31105 jj_consume_token(MOD);
31106 break;
31107 case OPERATOR:
31108 jj_consume_token(OPERATOR);
31109 break;
31110 case PRIVATE:
31111 jj_consume_token(PRIVATE);
31112 break;
31113 case RAW:
31114 jj_consume_token(RAW);
31115 break;
31116 case REPLACE:
31117 jj_consume_token(REPLACE);
31118 break;
31119 case STRING:
31120 jj_consume_token(STRING);
31121 break;
31122 case SQL:
31123 jj_consume_token(SQL);
31124 break;
31125 case SQLCODE:
31126 jj_consume_token(SQLCODE);
31127 break;
31128 case SQLERRM:
31129 jj_consume_token(SQLERRM);
31130 break;
31131 case SYSDATE:
31132 jj_consume_token(SYSDATE);
31133 break;
31134 case TYPE:
31135 jj_consume_token(TYPE);
31136 break;
31137 case LOOP:
31138 jj_consume_token(LOOP);
31139 break;
31140 case INT:
31141 jj_consume_token(INT);
31142 break;
31143 case ARRAY:
31144 jj_consume_token(ARRAY);
31145 break;
31146 default:
31147 jj_la1[443] = jj_gen;
31148 jj_consume_token(-1);
31149 throw new ParseException();
31150 }
31151 jjtree.closeNodeScope(jjtn000, true);
31152 jjtc000 = false;
31153 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31154 } catch (Throwable jjte000) {
31155 if (jjtc000) {
31156 jjtree.clearNodeScope(jjtn000);
31157 jjtc000 = false;
31158 } else {
31159 jjtree.popNode();
31160 }
31161 if (jjte000 instanceof RuntimeException) {
31162 {if (true) throw (RuntimeException)jjte000;}
31163 }
31164 if (jjte000 instanceof ParseException) {
31165 {if (true) throw (ParseException)jjte000;}
31166 }
31167 {if (true) throw (Error)jjte000;}
31168 } finally {
31169 if (jjtc000) {
31170 jjtree.closeNodeScope(jjtn000, true);
31171 }
31172 }
31173 throw new Error("Missing return statement in function");
31174 }
31175
31176
31177
31178
31179 final public ASTQualifiedID QualifiedID() throws ParseException {
31180
31181 ASTQualifiedID jjtn000 = new ASTQualifiedID(this, JJTQUALIFIEDID);
31182 boolean jjtc000 = true;
31183 jjtree.openNodeScope(jjtn000);
31184 try {
31185 switch (jj_nt.kind) {
31186 case IDENTIFIER:
31187 jj_consume_token(IDENTIFIER);
31188 break;
31189 case QUOTED_LITERAL:
31190 jj_consume_token(QUOTED_LITERAL);
31191 break;
31192 case DEFINER:
31193 case CURRENT_USER:
31194 case LANGUAGE:
31195 case ADD:
31196 case AGGREGATE:
31197 case AT:
31198 case ATTRIBUTE:
31199 case AUTHID:
31200 case BULK:
31201 case BYTE:
31202 case CASCADE:
31203 case CLOSE:
31204 case COALESCE:
31205 case COLLECT:
31206 case COLUMN:
31207 case COMMENT:
31208 case COMMIT:
31209 case CONSTRUCTOR:
31210 case CONTINUE:
31211 case CONVERT:
31212 case CURRENT:
31213 case CURSOR:
31214 case DATA:
31215 case DAY:
31216 case DISABLE:
31217 case EDITIONABLE:
31218 case ELEMENT:
31219 case ENABLE:
31220 case ESCAPE:
31221 case EXCEPT:
31222 case EXCEPTIONS:
31223 case EXIT:
31224 case EXTERNAL:
31225 case EXTENDS:
31226 case EXTRACT:
31227 case FALSE:
31228 case FINAL:
31229 case FORCE:
31230 case FUNCTION:
31231 case GLOBAL:
31232 case HASH:
31233 case HEAP:
31234 case HOUR:
31235 case IMMEDIATE:
31236 case INDICES:
31237 case INDEXTYPE:
31238 case INDICATOR:
31239 case INSTANTIABLE:
31240 case INTERVAL:
31241 case INVALIDATE:
31242 case ISOLATION:
31243 case JAVA:
31244 case LEVEL:
31245 case LIMIT:
31246 case MAP:
31247 case MAX:
31248 case MEMBER:
31249 case MERGE:
31250 case MIN:
31251 case MINUTE:
31252 case MLSLABEL:
31253 case MODIFY:
31254 case MONTH:
31255 case NATURAL:
31256 case NEW:
31257 case NO:
31258 case NONEDITIONABLE:
31259 case NULLIF:
31260 case OBJECT:
31261 case OID:
31262 case OPAQUE:
31263 case OPEN:
31264 case ORGANIZATION:
31265 case OTHERS:
31266 case OVERRIDING:
31267 case PACKAGE:
31268 case PARTITION:
31269 case PRESERVE:
31270 case PROCEDURE:
31271 case RANGE:
31272 case REAL:
31273 case RECORD:
31274 case REF:
31275 case RELEASE:
31276 case RELIES_ON:
31277 case RENAME:
31278 case RESULT:
31279 case RETURN:
31280 case RETURNING:
31281 case REVERSE:
31282 case ROLLBACK:
31283 case ROW:
31284 case ROWS:
31285 case ROWID:
31286 case ROWNUM:
31287 case SAVE:
31288 case SAVEPOINT:
31289 case SECOND:
31290 case SELF:
31291 case SET:
31292 case SPACE:
31293 case STATIC:
31294 case SUBTYPE:
31295 case SUBSTITUTABLE:
31296 case SUCCESSFUL:
31297 case SYS_REFCURSOR:
31298 case TEMPORARY:
31299 case TIME:
31300 case TIMESTAMP:
31301 case TIMEZONE_REGION:
31302 case TIMEZONE_ABBR:
31303 case TIMEZONE_MINUTE:
31304 case TIMEZONE_HOUR:
31305 case TRANSACTION:
31306 case TRUE:
31307 case UNDER:
31308 case USING:
31309 case YES:
31310 case SHOW:
31311 case A:
31312 case DOUBLE:
31313 case DEC:
31314 case PRECISION:
31315 case NUMERIC:
31316 case NCHAR:
31317 case NVARCHAR2:
31318 case UROWID:
31319 case VARRAY:
31320 case VARYING:
31321 case BFILE:
31322 case BLOB:
31323 case CLOB:
31324 case NCLOB:
31325 case YEAR:
31326 case LOCAL:
31327 case ZONE:
31328 case CHARACTER:
31329 case AFTER:
31330 case BEFORE:
31331 case OLD:
31332 case PARENT:
31333 case ANALYZE:
31334 case ASSOCIATE:
31335 case AUDIT:
31336 case COMPOUND:
31337 case DATABASE:
31338 case CALL:
31339 case DDL:
31340 case DISASSOCIATE:
31341 case EACH:
31342 case FOLLOWS:
31343 case LOGOFF:
31344 case LOGON:
31345 case NESTED:
31346 case NOAUDIT:
31347 case SCHEMA:
31348 case SERVERERROR:
31349 case SHUTDOWN:
31350 case STARTUP:
31351 case STATEMENT:
31352 case STATISTICS:
31353 case SUSPEND:
31354 case TRUNCATE:
31355 case WRAPPED:
31356 case LIBRARY:
31357 case NAME:
31358 case STRUCT:
31359 case CONTEXT:
31360 case PARAMETERS:
31361 case LENGTH:
31362 case TDO:
31363 case MAXLEN:
31364 case CHARSETID:
31365 case CHARSETFORM:
31366 case ACCEPT:
31367 case ACCESSIBLE:
31368 case COPY:
31369 case DEFINE:
31370 case DISCONNECT:
31371 case HOST:
31372 case PRINT:
31373 case QUIT:
31374 case REMARK:
31375 case UNDEFINE:
31376 case VARIABLE:
31377 case WHENEVER:
31378 case ATTACH:
31379 case CAST:
31380 case TREAT:
31381 case TRIM:
31382 case LEFT:
31383 case RIGHT:
31384 case BOTH:
31385 case EMPTY:
31386 case MULTISET:
31387 case SUBMULTISET:
31388 case LEADING:
31389 case TRAILING:
31390 case CHAR_CS:
31391 case NCHAR_CS:
31392 case DBTIMEZONE:
31393 case SESSIONTIMEZONE:
31394 case AUTHENTICATED:
31395 case LINK:
31396 case SHARED:
31397 case DIRECTORY:
31398 case USER:
31399 KEYWORD_UNRESERVED();
31400 break;
31401 case REPLACE:
31402 jj_consume_token(REPLACE);
31403 break;
31404 case SERIALLY_REUSABLE:
31405 jj_consume_token(SERIALLY_REUSABLE);
31406 break;
31407 case RESTRICT_REFERENCES:
31408 jj_consume_token(RESTRICT_REFERENCES);
31409 break;
31410 case EXCEPTION_INIT:
31411 jj_consume_token(EXCEPTION_INIT);
31412 break;
31413 case AUTONOMOUS_TRANSACTION:
31414 jj_consume_token(AUTONOMOUS_TRANSACTION);
31415 break;
31416 case ARRAY:
31417 jj_consume_token(ARRAY);
31418 break;
31419 case AVG:
31420 jj_consume_token(AVG);
31421 break;
31422 case BINARY_INTEGER:
31423 jj_consume_token(BINARY_INTEGER);
31424 break;
31425 case BODY:
31426 jj_consume_token(BODY);
31427 break;
31428 case BOOLEAN:
31429 jj_consume_token(BOOLEAN);
31430 break;
31431 case CHAR:
31432 jj_consume_token(CHAR);
31433 break;
31434 case CHAR_BASE:
31435 jj_consume_token(CHAR_BASE);
31436 break;
31437 case CONSTANT:
31438 jj_consume_token(CONSTANT);
31439 break;
31440 case CURRVAL:
31441 jj_consume_token(CURRVAL);
31442 break;
31443 case DATE:
31444 jj_consume_token(DATE);
31445 break;
31446 case DECIMAL:
31447 jj_consume_token(DECIMAL);
31448 break;
31449 case DELETE:
31450 jj_consume_token(DELETE);
31451 break;
31452 case DO:
31453 jj_consume_token(DO);
31454 break;
31455 case ELSIF:
31456 jj_consume_token(ELSIF);
31457 break;
31458 case EXECUTE:
31459 jj_consume_token(EXECUTE);
31460 break;
31461 case EXISTS:
31462 jj_consume_token(EXISTS);
31463 break;
31464 case FLOAT:
31465 jj_consume_token(FLOAT);
31466 break;
31467 case FORALL:
31468 jj_consume_token(FORALL);
31469 break;
31470 case INTEGER:
31471 jj_consume_token(INTEGER);
31472 break;
31473 case INTERFACE:
31474 jj_consume_token(INTERFACE);
31475 break;
31476 case LONG:
31477 jj_consume_token(LONG);
31478 break;
31479 case LOOP:
31480 jj_consume_token(LOOP);
31481 break;
31482 case MOD:
31483 jj_consume_token(MOD);
31484 break;
31485 case NATURALN:
31486 jj_consume_token(NATURALN);
31487 break;
31488 case NEXTVAL:
31489 jj_consume_token(NEXTVAL);
31490 break;
31491 case NOCOPY:
31492 jj_consume_token(NOCOPY);
31493 break;
31494 case NUMBER:
31495 jj_consume_token(NUMBER);
31496 break;
31497 case BFILE_BASE:
31498 jj_consume_token(BFILE_BASE);
31499 break;
31500 case BLOB_BASE:
31501 jj_consume_token(BLOB_BASE);
31502 break;
31503 case CLOB_BASE:
31504 jj_consume_token(CLOB_BASE);
31505 break;
31506 case DATE_BASE:
31507 jj_consume_token(DATE_BASE);
31508 break;
31509 case NUMBER_BASE:
31510 jj_consume_token(NUMBER_BASE);
31511 break;
31512 case OCIROWID:
31513 jj_consume_token(OCIROWID);
31514 break;
31515 case OPERATOR:
31516 jj_consume_token(OPERATOR);
31517 break;
31518 case OUT:
31519 jj_consume_token(OUT);
31520 break;
31521 case PLS_INTEGER:
31522 jj_consume_token(PLS_INTEGER);
31523 break;
31524 case POSITIVE:
31525 jj_consume_token(POSITIVE);
31526 break;
31527 case POSITIVEN:
31528 jj_consume_token(POSITIVEN);
31529 break;
31530 case PRAGMA:
31531 jj_consume_token(PRAGMA);
31532 break;
31533 case PRIOR:
31534 jj_consume_token(PRIOR);
31535 break;
31536 case PRIVATE:
31537 jj_consume_token(PRIVATE);
31538 break;
31539 case PROMPT:
31540 jj_consume_token(PROMPT);
31541 break;
31542 case RAISE:
31543 jj_consume_token(RAISE);
31544 break;
31545 case RAW:
31546 jj_consume_token(RAW);
31547 break;
31548 case ROWTYPE:
31549 jj_consume_token(ROWTYPE);
31550 break;
31551 case SEPARATE:
31552 jj_consume_token(SEPARATE);
31553 break;
31554 case SMALLINT:
31555 jj_consume_token(SMALLINT);
31556 break;
31557 case SQLCODE:
31558 jj_consume_token(SQLCODE);
31559 break;
31560 case SQLERRM:
31561 jj_consume_token(SQLERRM);
31562 break;
31563 case STDDEV:
31564 jj_consume_token(STDDEV);
31565 break;
31566 case SUM:
31567 jj_consume_token(SUM);
31568 break;
31569 case SYNONYM:
31570 jj_consume_token(SYNONYM);
31571 break;
31572 case SYSDATE:
31573 jj_consume_token(SYSDATE);
31574 break;
31575 case TRIGGER:
31576 jj_consume_token(TRIGGER);
31577 break;
31578 case TYPE:
31579 jj_consume_token(TYPE);
31580 break;
31581 case UI:
31582 jj_consume_token(UI);
31583 break;
31584 case VARCHAR:
31585 jj_consume_token(VARCHAR);
31586 break;
31587 case VARCHAR2:
31588 jj_consume_token(VARCHAR2);
31589 break;
31590 case INT:
31591 jj_consume_token(INT);
31592 break;
31593 case SIGNTYPE:
31594 jj_consume_token(SIGNTYPE);
31595 break;
31596 case STRING:
31597 jj_consume_token(STRING);
31598 break;
31599 case WHILE:
31600 jj_consume_token(WHILE);
31601 break;
31602 default:
31603 jj_la1[444] = jj_gen;
31604 jj_consume_token(-1);
31605 throw new ParseException();
31606 }
31607 jjtree.closeNodeScope(jjtn000, true);
31608 jjtc000 = false;
31609 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31610 } catch (Throwable jjte000) {
31611 if (jjtc000) {
31612 jjtree.clearNodeScope(jjtn000);
31613 jjtc000 = false;
31614 } else {
31615 jjtree.popNode();
31616 }
31617 if (jjte000 instanceof RuntimeException) {
31618 {if (true) throw (RuntimeException)jjte000;}
31619 }
31620 if (jjte000 instanceof ParseException) {
31621 {if (true) throw (ParseException)jjte000;}
31622 }
31623 {if (true) throw (Error)jjte000;}
31624 } finally {
31625 if (jjtc000) {
31626 jjtree.closeNodeScope(jjtn000, true);
31627 }
31628 }
31629 throw new Error("Missing return statement in function");
31630 }
31631
31632 final public ASTTypeKeyword TypeKeyword() throws ParseException {
31633
31634 ASTTypeKeyword jjtn000 = new ASTTypeKeyword(this, JJTTYPEKEYWORD);
31635 boolean jjtc000 = true;
31636 jjtree.openNodeScope(jjtn000);
31637 try {
31638 switch (jj_nt.kind) {
31639 case BFILE_BASE:
31640 jj_consume_token(BFILE_BASE);
31641 break;
31642 case BLOB_BASE:
31643 jj_consume_token(BLOB_BASE);
31644 break;
31645 case CLOB_BASE:
31646 jj_consume_token(CLOB_BASE);
31647 break;
31648 case DATE_BASE:
31649 jj_consume_token(DATE_BASE);
31650 break;
31651 case NUMBER_BASE:
31652 jj_consume_token(NUMBER_BASE);
31653 break;
31654 case BOOLEAN:
31655 jj_consume_token(BOOLEAN);
31656 break;
31657 case DATE:
31658 jj_consume_token(DATE);
31659 break;
31660 case NUMBER:
31661 jj_consume_token(NUMBER);
31662 break;
31663 case FLOAT:
31664 jj_consume_token(FLOAT);
31665 break;
31666 case REAL:
31667 jj_consume_token(REAL);
31668 break;
31669 case INTEGER:
31670 jj_consume_token(INTEGER);
31671 break;
31672 case INT:
31673 jj_consume_token(INT);
31674 break;
31675 case SMALLINT:
31676 jj_consume_token(SMALLINT);
31677 break;
31678 case DECIMAL:
31679 jj_consume_token(DECIMAL);
31680 break;
31681 case NUMERIC:
31682 jj_consume_token(NUMERIC);
31683 break;
31684 case DEC:
31685 jj_consume_token(DEC);
31686 break;
31687 case BINARY_INTEGER:
31688 jj_consume_token(BINARY_INTEGER);
31689 break;
31690 case NATURAL:
31691 jj_consume_token(NATURAL);
31692 break;
31693 case NATURALN:
31694 jj_consume_token(NATURALN);
31695 break;
31696 case POSITIVE:
31697 jj_consume_token(POSITIVE);
31698 break;
31699 case POSITIVEN:
31700 jj_consume_token(POSITIVEN);
31701 break;
31702 case SIGNTYPE:
31703 jj_consume_token(SIGNTYPE);
31704 break;
31705 case VARCHAR2:
31706 jj_consume_token(VARCHAR2);
31707 break;
31708 case VARCHAR:
31709 jj_consume_token(VARCHAR);
31710 break;
31711 case STRING:
31712 jj_consume_token(STRING);
31713 break;
31714 case LONG:
31715 jj_consume_token(LONG);
31716 break;
31717 case RAW:
31718 jj_consume_token(RAW);
31719 break;
31720 case ROWID:
31721 jj_consume_token(ROWID);
31722 break;
31723 case CHAR:
31724 jj_consume_token(CHAR);
31725 break;
31726 case CHARACTER:
31727 jj_consume_token(CHARACTER);
31728 break;
31729 case MLSLABEL:
31730 jj_consume_token(MLSLABEL);
31731 break;
31732 case BLOB:
31733 jj_consume_token(BLOB);
31734 break;
31735 case CLOB:
31736 jj_consume_token(CLOB);
31737 break;
31738 case BFILE:
31739 jj_consume_token(BFILE);
31740 break;
31741 case NCHAR:
31742 jj_consume_token(NCHAR);
31743 break;
31744 case NVARCHAR2:
31745 jj_consume_token(NVARCHAR2);
31746 break;
31747 case NCLOB:
31748 jj_consume_token(NCLOB);
31749 break;
31750 case PLS_INTEGER:
31751 jj_consume_token(PLS_INTEGER);
31752 break;
31753 case TIME:
31754 jj_consume_token(TIME);
31755 break;
31756 case TIMESTAMP:
31757 jj_consume_token(TIMESTAMP);
31758 break;
31759 case UROWID:
31760 jj_consume_token(UROWID);
31761 break;
31762 case ARRAY:
31763 jj_consume_token(ARRAY);
31764 break;
31765 case AUTHID:
31766 jj_consume_token(AUTHID);
31767 break;
31768 case ACCESSIBLE:
31769 jj_consume_token(ACCESSIBLE);
31770 jj_consume_token(CHAR_BASE);
31771 break;
31772 case CURRVAL:
31773 jj_consume_token(CURRVAL);
31774 break;
31775 case HOUR:
31776 jj_consume_token(HOUR);
31777 break;
31778 case INTERVAL:
31779 jj_consume_token(INTERVAL);
31780 break;
31781 case MONTH:
31782 jj_consume_token(MONTH);
31783 break;
31784 case OCIROWID:
31785 jj_consume_token(OCIROWID);
31786 break;
31787 case RECORD:
31788 jj_consume_token(RECORD);
31789 break;
31790 case REF:
31791 jj_consume_token(REF);
31792 break;
31793 case ROW:
31794 jj_consume_token(ROW);
31795 break;
31796 case ROWNUM:
31797 jj_consume_token(ROWNUM);
31798 break;
31799 case ROWTYPE:
31800 jj_consume_token(ROWTYPE);
31801 break;
31802 case SECOND:
31803 jj_consume_token(SECOND);
31804 break;
31805 case SET:
31806 jj_consume_token(SET);
31807 break;
31808 case TABLE:
31809 jj_consume_token(TABLE);
31810 break;
31811 case TIMEZONE_REGION:
31812 jj_consume_token(TIMEZONE_REGION);
31813 break;
31814 case TIMEZONE_ABBR:
31815 jj_consume_token(TIMEZONE_ABBR);
31816 break;
31817 case TIMEZONE_MINUTE:
31818 jj_consume_token(TIMEZONE_MINUTE);
31819 break;
31820 case TIMEZONE_HOUR:
31821 jj_consume_token(TIMEZONE_HOUR);
31822 break;
31823 case DOUBLE:
31824 jj_consume_token(DOUBLE);
31825 break;
31826 case PRECISION:
31827 jj_consume_token(PRECISION);
31828 break;
31829 case VARRAY:
31830 jj_consume_token(VARRAY);
31831 break;
31832 case YEAR:
31833 jj_consume_token(YEAR);
31834 break;
31835 case LOCAL:
31836 jj_consume_token(LOCAL);
31837 break;
31838 case WITH:
31839 jj_consume_token(WITH);
31840 break;
31841 case ZONE:
31842 jj_consume_token(ZONE);
31843 break;
31844 case JAVA_INTERFACE_CLASS:
31845 jj_consume_token(JAVA_INTERFACE_CLASS);
31846 break;
31847 case SQLDATA_CLASS:
31848 jj_consume_token(SQLDATA_CLASS);
31849 break;
31850 case CUSTOMDATUM_CLASS:
31851 jj_consume_token(CUSTOMDATUM_CLASS);
31852 break;
31853 case ORADATA_CLASS:
31854 jj_consume_token(ORADATA_CLASS);
31855 break;
31856 default:
31857 jj_la1[445] = jj_gen;
31858 jj_consume_token(-1);
31859 throw new ParseException();
31860 }
31861 jjtree.closeNodeScope(jjtn000, true);
31862 jjtc000 = false;
31863 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31864 } finally {
31865 if (jjtc000) {
31866 jjtree.closeNodeScope(jjtn000, true);
31867 }
31868 }
31869 throw new Error("Missing return statement in function");
31870 }
31871
31872 final public ASTJavaInterfaceClass JavaInterfaceClass() throws ParseException {
31873
31874 ASTJavaInterfaceClass jjtn000 = new ASTJavaInterfaceClass(this, JJTJAVAINTERFACECLASS);
31875 boolean jjtc000 = true;
31876 jjtree.openNodeScope(jjtn000);
31877 try {
31878 switch (jj_nt.kind) {
31879 case SQLDATA_CLASS:
31880 jj_consume_token(SQLDATA_CLASS);
31881 break;
31882 case CUSTOMDATUM_CLASS:
31883 jj_consume_token(CUSTOMDATUM_CLASS);
31884 break;
31885 case ORADATA_CLASS:
31886 jj_consume_token(ORADATA_CLASS);
31887 break;
31888 default:
31889 jj_la1[446] = jj_gen;
31890 jj_consume_token(-1);
31891 throw new ParseException();
31892 }
31893 jjtree.closeNodeScope(jjtn000, true);
31894 jjtc000 = false;
31895 jjtn000.setImage(token.toString()) ; jjtn000.value = token ; {if (true) return jjtn000 ;}
31896 } finally {
31897 if (jjtc000) {
31898 jjtree.closeNodeScope(jjtn000, true);
31899 }
31900 }
31901 throw new Error("Missing return statement in function");
31902 }
31903
31904
31905
31906
31907
31908
31909
31910 final public PLSQLNode EqualsOldIDNewID(PLSQLNode pOldID) throws ParseException {
31911
31912 ASTEqualsOldIDNewID jjtn000 = new ASTEqualsOldIDNewID(this, JJTEQUALSOLDIDNEWID);
31913 boolean jjtc000 = true;
31914 jjtree.openNodeScope(jjtn000);PLSQLNode newID;
31915 Token oldIDToken;
31916 Token newIDToken;
31917 try {
31918 newID = ID();
31919 jjtree.closeNodeScope(jjtn000, true);
31920 jjtc000 = false;
31921 oldIDToken = (Token) ((AbstractPLSQLNode)pOldID).value ;
31922 newIDToken = (Token) ((AbstractPLSQLNode)newID).value ;
31923 if (oldIDToken.image.equals(newIDToken.image)) {
31924 {if (true) return newID;}
31925 } else {
31926 {if (true) throw new ParseException("PLSQL syntax error on line "+newIDToken.beginLine+" at column "+newIDToken.beginColumn+"!\u005cn"
31927 + "Found \u005c""+newIDToken.image+"\u005c" but expected \u005c""+oldIDToken.image+"\u005c".");}
31928 }
31929 } catch (Throwable jjte000) {
31930 if (jjtc000) {
31931 jjtree.clearNodeScope(jjtn000);
31932 jjtc000 = false;
31933 } else {
31934 jjtree.popNode();
31935 }
31936 if (jjte000 instanceof RuntimeException) {
31937 {if (true) throw (RuntimeException)jjte000;}
31938 }
31939 if (jjte000 instanceof ParseException) {
31940 {if (true) throw (ParseException)jjte000;}
31941 }
31942 {if (true) throw (Error)jjte000;}
31943 } finally {
31944 if (jjtc000) {
31945 jjtree.closeNodeScope(jjtn000, true);
31946 }
31947 }
31948 throw new Error("Missing return statement in function");
31949 }
31950
31951 private boolean jj_2_1(int xla) {
31952 jj_la = xla; jj_lastpos = jj_scanpos = token;
31953 try { return !jj_3_1(); }
31954 catch(LookaheadSuccess ls) { return true; }
31955 finally { jj_save(0, xla); }
31956 }
31957
31958 private boolean jj_2_2(int xla) {
31959 jj_la = xla; jj_lastpos = jj_scanpos = token;
31960 try { return !jj_3_2(); }
31961 catch(LookaheadSuccess ls) { return true; }
31962 finally { jj_save(1, xla); }
31963 }
31964
31965 private boolean jj_2_3(int xla) {
31966 jj_la = xla; jj_lastpos = jj_scanpos = token;
31967 try { return !jj_3_3(); }
31968 catch(LookaheadSuccess ls) { return true; }
31969 finally { jj_save(2, xla); }
31970 }
31971
31972 private boolean jj_2_4(int xla) {
31973 jj_la = xla; jj_lastpos = jj_scanpos = token;
31974 try { return !jj_3_4(); }
31975 catch(LookaheadSuccess ls) { return true; }
31976 finally { jj_save(3, xla); }
31977 }
31978
31979 private boolean jj_2_5(int xla) {
31980 jj_la = xla; jj_lastpos = jj_scanpos = token;
31981 try { return !jj_3_5(); }
31982 catch(LookaheadSuccess ls) { return true; }
31983 finally { jj_save(4, xla); }
31984 }
31985
31986 private boolean jj_2_6(int xla) {
31987 jj_la = xla; jj_lastpos = jj_scanpos = token;
31988 try { return !jj_3_6(); }
31989 catch(LookaheadSuccess ls) { return true; }
31990 finally { jj_save(5, xla); }
31991 }
31992
31993 private boolean jj_2_7(int xla) {
31994 jj_la = xla; jj_lastpos = jj_scanpos = token;
31995 try { return !jj_3_7(); }
31996 catch(LookaheadSuccess ls) { return true; }
31997 finally { jj_save(6, xla); }
31998 }
31999
32000 private boolean jj_2_8(int xla) {
32001 jj_la = xla; jj_lastpos = jj_scanpos = token;
32002 try { return !jj_3_8(); }
32003 catch(LookaheadSuccess ls) { return true; }
32004 finally { jj_save(7, xla); }
32005 }
32006
32007 private boolean jj_2_9(int xla) {
32008 jj_la = xla; jj_lastpos = jj_scanpos = token;
32009 try { return !jj_3_9(); }
32010 catch(LookaheadSuccess ls) { return true; }
32011 finally { jj_save(8, xla); }
32012 }
32013
32014 private boolean jj_2_10(int xla) {
32015 jj_la = xla; jj_lastpos = jj_scanpos = token;
32016 try { return !jj_3_10(); }
32017 catch(LookaheadSuccess ls) { return true; }
32018 finally { jj_save(9, xla); }
32019 }
32020
32021 private boolean jj_2_11(int xla) {
32022 jj_la = xla; jj_lastpos = jj_scanpos = token;
32023 try { return !jj_3_11(); }
32024 catch(LookaheadSuccess ls) { return true; }
32025 finally { jj_save(10, xla); }
32026 }
32027
32028 private boolean jj_2_12(int xla) {
32029 jj_la = xla; jj_lastpos = jj_scanpos = token;
32030 try { return !jj_3_12(); }
32031 catch(LookaheadSuccess ls) { return true; }
32032 finally { jj_save(11, xla); }
32033 }
32034
32035 private boolean jj_2_13(int xla) {
32036 jj_la = xla; jj_lastpos = jj_scanpos = token;
32037 try { return !jj_3_13(); }
32038 catch(LookaheadSuccess ls) { return true; }
32039 finally { jj_save(12, xla); }
32040 }
32041
32042 private boolean jj_2_14(int xla) {
32043 jj_la = xla; jj_lastpos = jj_scanpos = token;
32044 try { return !jj_3_14(); }
32045 catch(LookaheadSuccess ls) { return true; }
32046 finally { jj_save(13, xla); }
32047 }
32048
32049 private boolean jj_2_15(int xla) {
32050 jj_la = xla; jj_lastpos = jj_scanpos = token;
32051 try { return !jj_3_15(); }
32052 catch(LookaheadSuccess ls) { return true; }
32053 finally { jj_save(14, xla); }
32054 }
32055
32056 private boolean jj_2_16(int xla) {
32057 jj_la = xla; jj_lastpos = jj_scanpos = token;
32058 try { return !jj_3_16(); }
32059 catch(LookaheadSuccess ls) { return true; }
32060 finally { jj_save(15, xla); }
32061 }
32062
32063 private boolean jj_2_17(int xla) {
32064 jj_la = xla; jj_lastpos = jj_scanpos = token;
32065 try { return !jj_3_17(); }
32066 catch(LookaheadSuccess ls) { return true; }
32067 finally { jj_save(16, xla); }
32068 }
32069
32070 private boolean jj_2_18(int xla) {
32071 jj_la = xla; jj_lastpos = jj_scanpos = token;
32072 try { return !jj_3_18(); }
32073 catch(LookaheadSuccess ls) { return true; }
32074 finally { jj_save(17, xla); }
32075 }
32076
32077 private boolean jj_2_19(int xla) {
32078 jj_la = xla; jj_lastpos = jj_scanpos = token;
32079 try { return !jj_3_19(); }
32080 catch(LookaheadSuccess ls) { return true; }
32081 finally { jj_save(18, xla); }
32082 }
32083
32084 private boolean jj_2_20(int xla) {
32085 jj_la = xla; jj_lastpos = jj_scanpos = token;
32086 try { return !jj_3_20(); }
32087 catch(LookaheadSuccess ls) { return true; }
32088 finally { jj_save(19, xla); }
32089 }
32090
32091 private boolean jj_2_21(int xla) {
32092 jj_la = xla; jj_lastpos = jj_scanpos = token;
32093 try { return !jj_3_21(); }
32094 catch(LookaheadSuccess ls) { return true; }
32095 finally { jj_save(20, xla); }
32096 }
32097
32098 private boolean jj_2_22(int xla) {
32099 jj_la = xla; jj_lastpos = jj_scanpos = token;
32100 try { return !jj_3_22(); }
32101 catch(LookaheadSuccess ls) { return true; }
32102 finally { jj_save(21, xla); }
32103 }
32104
32105 private boolean jj_2_23(int xla) {
32106 jj_la = xla; jj_lastpos = jj_scanpos = token;
32107 try { return !jj_3_23(); }
32108 catch(LookaheadSuccess ls) { return true; }
32109 finally { jj_save(22, xla); }
32110 }
32111
32112 private boolean jj_2_24(int xla) {
32113 jj_la = xla; jj_lastpos = jj_scanpos = token;
32114 try { return !jj_3_24(); }
32115 catch(LookaheadSuccess ls) { return true; }
32116 finally { jj_save(23, xla); }
32117 }
32118
32119 private boolean jj_2_25(int xla) {
32120 jj_la = xla; jj_lastpos = jj_scanpos = token;
32121 try { return !jj_3_25(); }
32122 catch(LookaheadSuccess ls) { return true; }
32123 finally { jj_save(24, xla); }
32124 }
32125
32126 private boolean jj_2_26(int xla) {
32127 jj_la = xla; jj_lastpos = jj_scanpos = token;
32128 try { return !jj_3_26(); }
32129 catch(LookaheadSuccess ls) { return true; }
32130 finally { jj_save(25, xla); }
32131 }
32132
32133 private boolean jj_2_27(int xla) {
32134 jj_la = xla; jj_lastpos = jj_scanpos = token;
32135 try { return !jj_3_27(); }
32136 catch(LookaheadSuccess ls) { return true; }
32137 finally { jj_save(26, xla); }
32138 }
32139
32140 private boolean jj_2_28(int xla) {
32141 jj_la = xla; jj_lastpos = jj_scanpos = token;
32142 try { return !jj_3_28(); }
32143 catch(LookaheadSuccess ls) { return true; }
32144 finally { jj_save(27, xla); }
32145 }
32146
32147 private boolean jj_2_29(int xla) {
32148 jj_la = xla; jj_lastpos = jj_scanpos = token;
32149 try { return !jj_3_29(); }
32150 catch(LookaheadSuccess ls) { return true; }
32151 finally { jj_save(28, xla); }
32152 }
32153
32154 private boolean jj_2_30(int xla) {
32155 jj_la = xla; jj_lastpos = jj_scanpos = token;
32156 try { return !jj_3_30(); }
32157 catch(LookaheadSuccess ls) { return true; }
32158 finally { jj_save(29, xla); }
32159 }
32160
32161 private boolean jj_2_31(int xla) {
32162 jj_la = xla; jj_lastpos = jj_scanpos = token;
32163 try { return !jj_3_31(); }
32164 catch(LookaheadSuccess ls) { return true; }
32165 finally { jj_save(30, xla); }
32166 }
32167
32168 private boolean jj_2_32(int xla) {
32169 jj_la = xla; jj_lastpos = jj_scanpos = token;
32170 try { return !jj_3_32(); }
32171 catch(LookaheadSuccess ls) { return true; }
32172 finally { jj_save(31, xla); }
32173 }
32174
32175 private boolean jj_2_33(int xla) {
32176 jj_la = xla; jj_lastpos = jj_scanpos = token;
32177 try { return !jj_3_33(); }
32178 catch(LookaheadSuccess ls) { return true; }
32179 finally { jj_save(32, xla); }
32180 }
32181
32182 private boolean jj_2_34(int xla) {
32183 jj_la = xla; jj_lastpos = jj_scanpos = token;
32184 try { return !jj_3_34(); }
32185 catch(LookaheadSuccess ls) { return true; }
32186 finally { jj_save(33, xla); }
32187 }
32188
32189 private boolean jj_2_35(int xla) {
32190 jj_la = xla; jj_lastpos = jj_scanpos = token;
32191 try { return !jj_3_35(); }
32192 catch(LookaheadSuccess ls) { return true; }
32193 finally { jj_save(34, xla); }
32194 }
32195
32196 private boolean jj_2_36(int xla) {
32197 jj_la = xla; jj_lastpos = jj_scanpos = token;
32198 try { return !jj_3_36(); }
32199 catch(LookaheadSuccess ls) { return true; }
32200 finally { jj_save(35, xla); }
32201 }
32202
32203 private boolean jj_2_37(int xla) {
32204 jj_la = xla; jj_lastpos = jj_scanpos = token;
32205 try { return !jj_3_37(); }
32206 catch(LookaheadSuccess ls) { return true; }
32207 finally { jj_save(36, xla); }
32208 }
32209
32210 private boolean jj_2_38(int xla) {
32211 jj_la = xla; jj_lastpos = jj_scanpos = token;
32212 try { return !jj_3_38(); }
32213 catch(LookaheadSuccess ls) { return true; }
32214 finally { jj_save(37, xla); }
32215 }
32216
32217 private boolean jj_2_39(int xla) {
32218 jj_la = xla; jj_lastpos = jj_scanpos = token;
32219 try { return !jj_3_39(); }
32220 catch(LookaheadSuccess ls) { return true; }
32221 finally { jj_save(38, xla); }
32222 }
32223
32224 private boolean jj_2_40(int xla) {
32225 jj_la = xla; jj_lastpos = jj_scanpos = token;
32226 try { return !jj_3_40(); }
32227 catch(LookaheadSuccess ls) { return true; }
32228 finally { jj_save(39, xla); }
32229 }
32230
32231 private boolean jj_2_41(int xla) {
32232 jj_la = xla; jj_lastpos = jj_scanpos = token;
32233 try { return !jj_3_41(); }
32234 catch(LookaheadSuccess ls) { return true; }
32235 finally { jj_save(40, xla); }
32236 }
32237
32238 private boolean jj_2_42(int xla) {
32239 jj_la = xla; jj_lastpos = jj_scanpos = token;
32240 try { return !jj_3_42(); }
32241 catch(LookaheadSuccess ls) { return true; }
32242 finally { jj_save(41, xla); }
32243 }
32244
32245 private boolean jj_2_43(int xla) {
32246 jj_la = xla; jj_lastpos = jj_scanpos = token;
32247 try { return !jj_3_43(); }
32248 catch(LookaheadSuccess ls) { return true; }
32249 finally { jj_save(42, xla); }
32250 }
32251
32252 private boolean jj_2_44(int xla) {
32253 jj_la = xla; jj_lastpos = jj_scanpos = token;
32254 try { return !jj_3_44(); }
32255 catch(LookaheadSuccess ls) { return true; }
32256 finally { jj_save(43, xla); }
32257 }
32258
32259 private boolean jj_2_45(int xla) {
32260 jj_la = xla; jj_lastpos = jj_scanpos = token;
32261 try { return !jj_3_45(); }
32262 catch(LookaheadSuccess ls) { return true; }
32263 finally { jj_save(44, xla); }
32264 }
32265
32266 private boolean jj_2_46(int xla) {
32267 jj_la = xla; jj_lastpos = jj_scanpos = token;
32268 try { return !jj_3_46(); }
32269 catch(LookaheadSuccess ls) { return true; }
32270 finally { jj_save(45, xla); }
32271 }
32272
32273 private boolean jj_2_47(int xla) {
32274 jj_la = xla; jj_lastpos = jj_scanpos = token;
32275 try { return !jj_3_47(); }
32276 catch(LookaheadSuccess ls) { return true; }
32277 finally { jj_save(46, xla); }
32278 }
32279
32280 private boolean jj_2_48(int xla) {
32281 jj_la = xla; jj_lastpos = jj_scanpos = token;
32282 try { return !jj_3_48(); }
32283 catch(LookaheadSuccess ls) { return true; }
32284 finally { jj_save(47, xla); }
32285 }
32286
32287 private boolean jj_2_49(int xla) {
32288 jj_la = xla; jj_lastpos = jj_scanpos = token;
32289 try { return !jj_3_49(); }
32290 catch(LookaheadSuccess ls) { return true; }
32291 finally { jj_save(48, xla); }
32292 }
32293
32294 private boolean jj_2_50(int xla) {
32295 jj_la = xla; jj_lastpos = jj_scanpos = token;
32296 try { return !jj_3_50(); }
32297 catch(LookaheadSuccess ls) { return true; }
32298 finally { jj_save(49, xla); }
32299 }
32300
32301 private boolean jj_2_51(int xla) {
32302 jj_la = xla; jj_lastpos = jj_scanpos = token;
32303 try { return !jj_3_51(); }
32304 catch(LookaheadSuccess ls) { return true; }
32305 finally { jj_save(50, xla); }
32306 }
32307
32308 private boolean jj_2_52(int xla) {
32309 jj_la = xla; jj_lastpos = jj_scanpos = token;
32310 try { return !jj_3_52(); }
32311 catch(LookaheadSuccess ls) { return true; }
32312 finally { jj_save(51, xla); }
32313 }
32314
32315 private boolean jj_2_53(int xla) {
32316 jj_la = xla; jj_lastpos = jj_scanpos = token;
32317 try { return !jj_3_53(); }
32318 catch(LookaheadSuccess ls) { return true; }
32319 finally { jj_save(52, xla); }
32320 }
32321
32322 private boolean jj_2_54(int xla) {
32323 jj_la = xla; jj_lastpos = jj_scanpos = token;
32324 try { return !jj_3_54(); }
32325 catch(LookaheadSuccess ls) { return true; }
32326 finally { jj_save(53, xla); }
32327 }
32328
32329 private boolean jj_2_55(int xla) {
32330 jj_la = xla; jj_lastpos = jj_scanpos = token;
32331 try { return !jj_3_55(); }
32332 catch(LookaheadSuccess ls) { return true; }
32333 finally { jj_save(54, xla); }
32334 }
32335
32336 private boolean jj_2_56(int xla) {
32337 jj_la = xla; jj_lastpos = jj_scanpos = token;
32338 try { return !jj_3_56(); }
32339 catch(LookaheadSuccess ls) { return true; }
32340 finally { jj_save(55, xla); }
32341 }
32342
32343 private boolean jj_2_57(int xla) {
32344 jj_la = xla; jj_lastpos = jj_scanpos = token;
32345 try { return !jj_3_57(); }
32346 catch(LookaheadSuccess ls) { return true; }
32347 finally { jj_save(56, xla); }
32348 }
32349
32350 private boolean jj_2_58(int xla) {
32351 jj_la = xla; jj_lastpos = jj_scanpos = token;
32352 try { return !jj_3_58(); }
32353 catch(LookaheadSuccess ls) { return true; }
32354 finally { jj_save(57, xla); }
32355 }
32356
32357 private boolean jj_2_59(int xla) {
32358 jj_la = xla; jj_lastpos = jj_scanpos = token;
32359 try { return !jj_3_59(); }
32360 catch(LookaheadSuccess ls) { return true; }
32361 finally { jj_save(58, xla); }
32362 }
32363
32364 private boolean jj_2_60(int xla) {
32365 jj_la = xla; jj_lastpos = jj_scanpos = token;
32366 try { return !jj_3_60(); }
32367 catch(LookaheadSuccess ls) { return true; }
32368 finally { jj_save(59, xla); }
32369 }
32370
32371 private boolean jj_2_61(int xla) {
32372 jj_la = xla; jj_lastpos = jj_scanpos = token;
32373 try { return !jj_3_61(); }
32374 catch(LookaheadSuccess ls) { return true; }
32375 finally { jj_save(60, xla); }
32376 }
32377
32378 private boolean jj_2_62(int xla) {
32379 jj_la = xla; jj_lastpos = jj_scanpos = token;
32380 try { return !jj_3_62(); }
32381 catch(LookaheadSuccess ls) { return true; }
32382 finally { jj_save(61, xla); }
32383 }
32384
32385 private boolean jj_2_63(int xla) {
32386 jj_la = xla; jj_lastpos = jj_scanpos = token;
32387 try { return !jj_3_63(); }
32388 catch(LookaheadSuccess ls) { return true; }
32389 finally { jj_save(62, xla); }
32390 }
32391
32392 private boolean jj_2_64(int xla) {
32393 jj_la = xla; jj_lastpos = jj_scanpos = token;
32394 try { return !jj_3_64(); }
32395 catch(LookaheadSuccess ls) { return true; }
32396 finally { jj_save(63, xla); }
32397 }
32398
32399 private boolean jj_2_65(int xla) {
32400 jj_la = xla; jj_lastpos = jj_scanpos = token;
32401 try { return !jj_3_65(); }
32402 catch(LookaheadSuccess ls) { return true; }
32403 finally { jj_save(64, xla); }
32404 }
32405
32406 private boolean jj_2_66(int xla) {
32407 jj_la = xla; jj_lastpos = jj_scanpos = token;
32408 try { return !jj_3_66(); }
32409 catch(LookaheadSuccess ls) { return true; }
32410 finally { jj_save(65, xla); }
32411 }
32412
32413 private boolean jj_2_67(int xla) {
32414 jj_la = xla; jj_lastpos = jj_scanpos = token;
32415 try { return !jj_3_67(); }
32416 catch(LookaheadSuccess ls) { return true; }
32417 finally { jj_save(66, xla); }
32418 }
32419
32420 private boolean jj_2_68(int xla) {
32421 jj_la = xla; jj_lastpos = jj_scanpos = token;
32422 try { return !jj_3_68(); }
32423 catch(LookaheadSuccess ls) { return true; }
32424 finally { jj_save(67, xla); }
32425 }
32426
32427 private boolean jj_2_69(int xla) {
32428 jj_la = xla; jj_lastpos = jj_scanpos = token;
32429 try { return !jj_3_69(); }
32430 catch(LookaheadSuccess ls) { return true; }
32431 finally { jj_save(68, xla); }
32432 }
32433
32434 private boolean jj_2_70(int xla) {
32435 jj_la = xla; jj_lastpos = jj_scanpos = token;
32436 try { return !jj_3_70(); }
32437 catch(LookaheadSuccess ls) { return true; }
32438 finally { jj_save(69, xla); }
32439 }
32440
32441 private boolean jj_2_71(int xla) {
32442 jj_la = xla; jj_lastpos = jj_scanpos = token;
32443 try { return !jj_3_71(); }
32444 catch(LookaheadSuccess ls) { return true; }
32445 finally { jj_save(70, xla); }
32446 }
32447
32448 private boolean jj_2_72(int xla) {
32449 jj_la = xla; jj_lastpos = jj_scanpos = token;
32450 try { return !jj_3_72(); }
32451 catch(LookaheadSuccess ls) { return true; }
32452 finally { jj_save(71, xla); }
32453 }
32454
32455 private boolean jj_2_73(int xla) {
32456 jj_la = xla; jj_lastpos = jj_scanpos = token;
32457 try { return !jj_3_73(); }
32458 catch(LookaheadSuccess ls) { return true; }
32459 finally { jj_save(72, xla); }
32460 }
32461
32462 private boolean jj_2_74(int xla) {
32463 jj_la = xla; jj_lastpos = jj_scanpos = token;
32464 try { return !jj_3_74(); }
32465 catch(LookaheadSuccess ls) { return true; }
32466 finally { jj_save(73, xla); }
32467 }
32468
32469 private boolean jj_2_75(int xla) {
32470 jj_la = xla; jj_lastpos = jj_scanpos = token;
32471 try { return !jj_3_75(); }
32472 catch(LookaheadSuccess ls) { return true; }
32473 finally { jj_save(74, xla); }
32474 }
32475
32476 private boolean jj_2_76(int xla) {
32477 jj_la = xla; jj_lastpos = jj_scanpos = token;
32478 try { return !jj_3_76(); }
32479 catch(LookaheadSuccess ls) { return true; }
32480 finally { jj_save(75, xla); }
32481 }
32482
32483 private boolean jj_2_77(int xla) {
32484 jj_la = xla; jj_lastpos = jj_scanpos = token;
32485 try { return !jj_3_77(); }
32486 catch(LookaheadSuccess ls) { return true; }
32487 finally { jj_save(76, xla); }
32488 }
32489
32490 private boolean jj_2_78(int xla) {
32491 jj_la = xla; jj_lastpos = jj_scanpos = token;
32492 try { return !jj_3_78(); }
32493 catch(LookaheadSuccess ls) { return true; }
32494 finally { jj_save(77, xla); }
32495 }
32496
32497 private boolean jj_2_79(int xla) {
32498 jj_la = xla; jj_lastpos = jj_scanpos = token;
32499 try { return !jj_3_79(); }
32500 catch(LookaheadSuccess ls) { return true; }
32501 finally { jj_save(78, xla); }
32502 }
32503
32504 private boolean jj_2_80(int xla) {
32505 jj_la = xla; jj_lastpos = jj_scanpos = token;
32506 try { return !jj_3_80(); }
32507 catch(LookaheadSuccess ls) { return true; }
32508 finally { jj_save(79, xla); }
32509 }
32510
32511 private boolean jj_2_81(int xla) {
32512 jj_la = xla; jj_lastpos = jj_scanpos = token;
32513 try { return !jj_3_81(); }
32514 catch(LookaheadSuccess ls) { return true; }
32515 finally { jj_save(80, xla); }
32516 }
32517
32518 private boolean jj_2_82(int xla) {
32519 jj_la = xla; jj_lastpos = jj_scanpos = token;
32520 try { return !jj_3_82(); }
32521 catch(LookaheadSuccess ls) { return true; }
32522 finally { jj_save(81, xla); }
32523 }
32524
32525 private boolean jj_2_83(int xla) {
32526 jj_la = xla; jj_lastpos = jj_scanpos = token;
32527 try { return !jj_3_83(); }
32528 catch(LookaheadSuccess ls) { return true; }
32529 finally { jj_save(82, xla); }
32530 }
32531
32532 private boolean jj_3_80() {
32533 if (jj_3R_151()) return true;
32534 return false;
32535 }
32536
32537 private boolean jj_3_79() {
32538 if (jj_3R_118()) return true;
32539 return false;
32540 }
32541
32542 private boolean jj_3R_175() {
32543 if (jj_3R_266()) return true;
32544 return false;
32545 }
32546
32547 private boolean jj_3R_621() {
32548 if (jj_scan_token(3)) return true;
32549 Token xsp;
32550 xsp = jj_scanpos;
32551 if (jj_scan_token(417)) {
32552 jj_scanpos = xsp;
32553 if (jj_scan_token(425)) {
32554 jj_scanpos = xsp;
32555 if (jj_3R_622()) return true;
32556 }
32557 }
32558 return false;
32559 }
32560
32561 private boolean jj_3R_593() {
32562 if (jj_scan_token(9)) return true;
32563 if (jj_scan_token(10)) return true;
32564 return false;
32565 }
32566
32567 private boolean jj_3R_288() {
32568 if (jj_scan_token(PARAMETERS)) return true;
32569 if (jj_3R_558()) return true;
32570 return false;
32571 }
32572
32573 private boolean jj_3R_560() {
32574 Token xsp;
32575 xsp = jj_scanpos;
32576 if (jj_3R_593()) {
32577 jj_scanpos = xsp;
32578 if (jj_scan_token(91)) return true;
32579 }
32580 if (jj_3R_232()) return true;
32581 return false;
32582 }
32583
32584 private boolean jj_3R_520() {
32585 if (jj_scan_token(5)) return true;
32586 if (jj_3R_126()) return true;
32587 if (jj_scan_token(7)) return true;
32588 return false;
32589 }
32590
32591 private boolean jj_3R_287() {
32592 if (jj_scan_token(WITH)) return true;
32593 if (jj_scan_token(CONTEXT)) return true;
32594 return false;
32595 }
32596
32597 private boolean jj_3R_150() {
32598 if (jj_scan_token(6)) return true;
32599 if (jj_3R_123()) return true;
32600 return false;
32601 }
32602
32603 private boolean jj_3R_286() {
32604 if (jj_scan_token(NAME)) return true;
32605 Token xsp;
32606 xsp = jj_scanpos;
32607 if (jj_scan_token(417)) {
32608 jj_scanpos = xsp;
32609 if (jj_scan_token(425)) {
32610 jj_scanpos = xsp;
32611 if (jj_3R_557()) return true;
32612 }
32613 }
32614 return false;
32615 }
32616
32617 private boolean jj_3R_522() {
32618 if (jj_scan_token(INDEX)) return true;
32619 if (jj_scan_token(BY)) return true;
32620 if (jj_3R_234()) return true;
32621 return false;
32622 }
32623
32624 private boolean jj_3R_518() {
32625 if (jj_scan_token(6)) return true;
32626 if (jj_3R_516()) return true;
32627 return false;
32628 }
32629
32630 private boolean jj_3R_199() {
32631 Token xsp;
32632 xsp = jj_scanpos;
32633 if (jj_3R_285()) {
32634 jj_scanpos = xsp;
32635 if (jj_3R_286()) {
32636 jj_scanpos = xsp;
32637 if (jj_3R_287()) {
32638 jj_scanpos = xsp;
32639 if (jj_3R_288()) return true;
32640 }
32641 }
32642 }
32643 return false;
32644 }
32645
32646 private boolean jj_3R_285() {
32647 if (jj_scan_token(LIBRARY)) return true;
32648 Token xsp;
32649 xsp = jj_scanpos;
32650 if (jj_scan_token(417)) {
32651 jj_scanpos = xsp;
32652 if (jj_scan_token(425)) {
32653 jj_scanpos = xsp;
32654 if (jj_3R_556()) return true;
32655 }
32656 }
32657 xsp = jj_scanpos;
32658 if (jj_3R_621()) jj_scanpos = xsp;
32659 return false;
32660 }
32661
32662 private boolean jj_3R_149() {
32663 if (jj_scan_token(6)) return true;
32664 if (jj_3R_123()) return true;
32665 return false;
32666 }
32667
32668 private boolean jj_3R_517() {
32669 if (jj_scan_token(6)) return true;
32670 if (jj_3R_516()) return true;
32671 return false;
32672 }
32673
32674 private boolean jj_3R_198() {
32675 if (jj_scan_token(LANGUAGE)) return true;
32676 Token xsp;
32677 xsp = jj_scanpos;
32678 if (jj_scan_token(417)) {
32679 jj_scanpos = xsp;
32680 if (jj_scan_token(152)) return true;
32681 }
32682 return false;
32683 }
32684
32685 private boolean jj_3R_559() {
32686 Token xsp;
32687 xsp = jj_scanpos;
32688 if (jj_scan_token(181)) jj_scanpos = xsp;
32689 if (jj_scan_token(NULL)) return true;
32690 return false;
32691 }
32692
32693 private boolean jj_3R_524() {
32694 if (jj_scan_token(6)) return true;
32695 if (jj_3R_232()) return true;
32696 return false;
32697 }
32698
32699 private boolean jj_3R_519() {
32700 if (jj_scan_token(VARYING)) return true;
32701 if (jj_scan_token(ARRAY)) return true;
32702 return false;
32703 }
32704
32705 private boolean jj_3_74() {
32706 if (jj_3R_123()) return true;
32707 if (jj_scan_token(3)) return true;
32708 return false;
32709 }
32710
32711 private boolean jj_3_77() {
32712 if (jj_3R_123()) return true;
32713 if (jj_scan_token(3)) return true;
32714 return false;
32715 }
32716
32717 private boolean jj_3R_523() {
32718 if (jj_scan_token(RETURN)) return true;
32719 if (jj_3R_234()) return true;
32720 return false;
32721 }
32722
32723 private boolean jj_3R_521() {
32724 if (jj_scan_token(NOT)) return true;
32725 if (jj_scan_token(NULL)) return true;
32726 return false;
32727 }
32728
32729 private boolean jj_3_73() {
32730 if (jj_scan_token(OF)) return true;
32731 if (jj_3R_123()) return true;
32732 Token xsp;
32733 while (true) {
32734 xsp = jj_scanpos;
32735 if (jj_3R_150()) { jj_scanpos = xsp; break; }
32736 }
32737 return false;
32738 }
32739
32740 private boolean jj_3R_122() {
32741 Token xsp;
32742 xsp = jj_scanpos;
32743 if (jj_scan_token(113)) {
32744 jj_scanpos = xsp;
32745 if (jj_3R_198()) return true;
32746 }
32747 while (true) {
32748 xsp = jj_scanpos;
32749 if (jj_3R_199()) { jj_scanpos = xsp; break; }
32750 }
32751 return false;
32752 }
32753
32754 private boolean jj_3R_493() {
32755 if (jj_3R_234()) return true;
32756 return false;
32757 }
32758
32759 private boolean jj_3_72() {
32760 if (jj_scan_token(OF)) return true;
32761 if (jj_3R_123()) return true;
32762 Token xsp;
32763 while (true) {
32764 xsp = jj_scanpos;
32765 if (jj_3R_149()) { jj_scanpos = xsp; break; }
32766 }
32767 return false;
32768 }
32769
32770 private boolean jj_3R_492() {
32771 if (jj_scan_token(5)) return true;
32772 if (jj_3R_232()) return true;
32773 Token xsp;
32774 while (true) {
32775 xsp = jj_scanpos;
32776 if (jj_3R_524()) { jj_scanpos = xsp; break; }
32777 }
32778 if (jj_scan_token(7)) return true;
32779 return false;
32780 }
32781
32782 private boolean jj_3R_491() {
32783 if (jj_scan_token(REF)) return true;
32784 if (jj_scan_token(CURSOR)) return true;
32785 Token xsp;
32786 xsp = jj_scanpos;
32787 if (jj_3R_523()) jj_scanpos = xsp;
32788 return false;
32789 }
32790
32791 private boolean jj_3R_516() {
32792 if (jj_3R_123()) return true;
32793 if (jj_3R_234()) return true;
32794 Token xsp;
32795 xsp = jj_scanpos;
32796 if (jj_3R_559()) jj_scanpos = xsp;
32797 xsp = jj_scanpos;
32798 if (jj_3R_560()) jj_scanpos = xsp;
32799 return false;
32800 }
32801
32802 private boolean jj_3R_490() {
32803 Token xsp;
32804 xsp = jj_scanpos;
32805 if (jj_scan_token(268)) {
32806 jj_scanpos = xsp;
32807 if (jj_scan_token(307)) {
32808 jj_scanpos = xsp;
32809 if (jj_3R_519()) return true;
32810 }
32811 }
32812 xsp = jj_scanpos;
32813 if (jj_3R_520()) jj_scanpos = xsp;
32814 if (jj_scan_token(OF)) return true;
32815 if (jj_3R_234()) return true;
32816 xsp = jj_scanpos;
32817 if (jj_3R_521()) jj_scanpos = xsp;
32818 xsp = jj_scanpos;
32819 if (jj_3R_522()) jj_scanpos = xsp;
32820 return false;
32821 }
32822
32823 private boolean jj_3R_489() {
32824 if (jj_scan_token(RECORD)) return true;
32825 if (jj_scan_token(5)) return true;
32826 if (jj_3R_516()) return true;
32827 Token xsp;
32828 while (true) {
32829 xsp = jj_scanpos;
32830 if (jj_3R_518()) { jj_scanpos = xsp; break; }
32831 }
32832 if (jj_scan_token(7)) return true;
32833 return false;
32834 }
32835
32836 private boolean jj_3R_488() {
32837 if (jj_scan_token(OBJECT)) return true;
32838 if (jj_scan_token(5)) return true;
32839 if (jj_3R_516()) return true;
32840 Token xsp;
32841 while (true) {
32842 xsp = jj_scanpos;
32843 if (jj_3R_517()) { jj_scanpos = xsp; break; }
32844 }
32845 if (jj_scan_token(7)) return true;
32846 return false;
32847 }
32848
32849 private boolean jj_3R_265() {
32850 Token xsp;
32851 xsp = jj_scanpos;
32852 if (jj_scan_token(99)) {
32853 jj_scanpos = xsp;
32854 if (jj_scan_token(180)) return true;
32855 }
32856 return false;
32857 }
32858
32859 private boolean jj_3R_630() {
32860 if (jj_3R_172()) return true;
32861 return false;
32862 }
32863
32864 private boolean jj_3_44() {
32865 if (jj_scan_token(NEW)) return true;
32866 Token xsp;
32867 xsp = jj_scanpos;
32868 if (jj_scan_token(67)) {
32869 jj_scanpos = xsp;
32870 if (jj_scan_token(189)) {
32871 jj_scanpos = xsp;
32872 if (jj_scan_token(188)) {
32873 jj_scanpos = xsp;
32874 if (jj_scan_token(187)) {
32875 jj_scanpos = xsp;
32876 if (jj_scan_token(186)) {
32877 jj_scanpos = xsp;
32878 if (jj_scan_token(190)) return true;
32879 }
32880 }
32881 }
32882 }
32883 }
32884 return false;
32885 }
32886
32887 private boolean jj_3R_267() {
32888 Token xsp;
32889 xsp = jj_scanpos;
32890 if (jj_scan_token(92)) {
32891 jj_scanpos = xsp;
32892 if (jj_scan_token(142)) {
32893 jj_scanpos = xsp;
32894 if (jj_scan_token(294)) return true;
32895 }
32896 }
32897 return false;
32898 }
32899
32900 private boolean jj_3_75() {
32901 if (jj_3R_123()) return true;
32902 if (jj_scan_token(3)) return true;
32903 return false;
32904 }
32905
32906 private boolean jj_3R_177() {
32907 Token xsp;
32908 xsp = jj_scanpos;
32909 if (jj_3_75()) jj_scanpos = xsp;
32910 if (jj_3R_123()) return true;
32911 return false;
32912 }
32913
32914 private boolean jj_3_76() {
32915 if (jj_scan_token(NESTED)) return true;
32916 if (jj_scan_token(TABLE)) return true;
32917 return false;
32918 }
32919
32920 private boolean jj_3R_176() {
32921 if (jj_scan_token(OR)) return true;
32922 Token xsp;
32923 xsp = jj_scanpos;
32924 if (jj_3R_267()) {
32925 jj_scanpos = xsp;
32926 if (jj_3R_268()) return true;
32927 }
32928 return false;
32929 }
32930
32931 private boolean jj_3R_174() {
32932 Token xsp;
32933 xsp = jj_scanpos;
32934 if (jj_scan_token(92)) {
32935 jj_scanpos = xsp;
32936 if (jj_scan_token(142)) {
32937 jj_scanpos = xsp;
32938 if (jj_scan_token(294)) return true;
32939 }
32940 }
32941 xsp = jj_scanpos;
32942 if (jj_3_72()) jj_scanpos = xsp;
32943 return false;
32944 }
32945
32946 private boolean jj_3R_589() {
32947 if (jj_3R_172()) return true;
32948 return false;
32949 }
32950
32951 private boolean jj_3R_264() {
32952 if (jj_scan_token(OR)) return true;
32953 if (jj_scan_token(REPLACE)) return true;
32954 return false;
32955 }
32956
32957 private boolean jj_3R_487() {
32958 if (jj_scan_token(NOT)) return true;
32959 if (jj_scan_token(NULL)) return true;
32960 return false;
32961 }
32962
32963 private boolean jj_3R_515() {
32964 if (jj_scan_token(RANGE)) return true;
32965 if (jj_3R_478()) return true;
32966 if (jj_scan_token(12)) return true;
32967 if (jj_3R_478()) return true;
32968 return false;
32969 }
32970
32971 private boolean jj_3R_514() {
32972 if (jj_scan_token(5)) return true;
32973 if (jj_scan_token(IDENTIFIER)) return true;
32974 if (jj_scan_token(7)) return true;
32975 return false;
32976 }
32977
32978 private boolean jj_3R_486() {
32979 Token xsp;
32980 xsp = jj_scanpos;
32981 if (jj_3R_514()) {
32982 jj_scanpos = xsp;
32983 if (jj_3R_515()) return true;
32984 }
32985 return false;
32986 }
32987
32988 private boolean jj_3R_631() {
32989 if (jj_scan_token(IN)) return true;
32990 Token xsp;
32991 xsp = jj_scanpos;
32992 if (jj_scan_token(204)) jj_scanpos = xsp;
32993 return false;
32994 }
32995
32996 private boolean jj_3R_629() {
32997 Token xsp;
32998 xsp = jj_scanpos;
32999 if (jj_3R_631()) {
33000 jj_scanpos = xsp;
33001 if (jj_scan_token(204)) return true;
33002 }
33003 return false;
33004 }
33005
33006 private boolean jj_3R_242() {
33007 if (jj_scan_token(TYPE)) return true;
33008 if (jj_3R_119()) return true;
33009 Token xsp;
33010 xsp = jj_scanpos;
33011 if (jj_scan_token(150)) {
33012 jj_scanpos = xsp;
33013 if (jj_scan_token(50)) return true;
33014 }
33015 xsp = jj_scanpos;
33016 if (jj_3_44()) {
33017 jj_scanpos = xsp;
33018 if (jj_3R_488()) {
33019 jj_scanpos = xsp;
33020 if (jj_3R_489()) {
33021 jj_scanpos = xsp;
33022 if (jj_3R_490()) {
33023 jj_scanpos = xsp;
33024 if (jj_3R_491()) {
33025 jj_scanpos = xsp;
33026 if (jj_3R_492()) {
33027 jj_scanpos = xsp;
33028 if (jj_3R_493()) return true;
33029 }
33030 }
33031 }
33032 }
33033 }
33034 }
33035 return false;
33036 }
33037
33038 private boolean jj_3R_173() {
33039 if (jj_scan_token(CREATE)) return true;
33040 Token xsp;
33041 xsp = jj_scanpos;
33042 if (jj_3R_264()) jj_scanpos = xsp;
33043 xsp = jj_scanpos;
33044 if (jj_3R_265()) jj_scanpos = xsp;
33045 return false;
33046 }
33047
33048 private boolean jj_3R_626() {
33049 if (jj_scan_token(6)) return true;
33050 if (jj_3R_232()) return true;
33051 return false;
33052 }
33053
33054 private boolean jj_3R_625() {
33055 if (jj_scan_token(6)) return true;
33056 Token xsp;
33057 xsp = jj_scanpos;
33058 if (jj_3R_629()) jj_scanpos = xsp;
33059 if (jj_3R_232()) return true;
33060 return false;
33061 }
33062
33063 private boolean jj_3R_107() {
33064 Token xsp;
33065 xsp = jj_scanpos;
33066 if (jj_3R_173()) jj_scanpos = xsp;
33067 if (jj_scan_token(TRIGGER)) return true;
33068 if (jj_3R_153()) return true;
33069 xsp = jj_scanpos;
33070 if (jj_scan_token(319)) {
33071 jj_scanpos = xsp;
33072 if (jj_scan_token(318)) {
33073 jj_scanpos = xsp;
33074 if (jj_scan_token(320)) {
33075 jj_scanpos = xsp;
33076 if (jj_scan_token(120)) return true;
33077 }
33078 }
33079 }
33080 xsp = jj_scanpos;
33081 if (jj_3R_174()) {
33082 jj_scanpos = xsp;
33083 if (jj_3R_175()) return true;
33084 }
33085 while (true) {
33086 xsp = jj_scanpos;
33087 if (jj_3R_176()) { jj_scanpos = xsp; break; }
33088 }
33089 if (jj_scan_token(ON)) return true;
33090 xsp = jj_scanpos;
33091 if (jj_scan_token(345)) {
33092 jj_scanpos = xsp;
33093 if (jj_3_76()) {
33094 jj_scanpos = xsp;
33095 if (jj_3R_177()) return true;
33096 }
33097 }
33098 return false;
33099 }
33100
33101 private boolean jj_3R_241() {
33102 if (jj_scan_token(SUBTYPE)) return true;
33103 if (jj_3R_119()) return true;
33104 if (jj_scan_token(IS)) return true;
33105 if (jj_3R_234()) return true;
33106 Token xsp;
33107 xsp = jj_scanpos;
33108 if (jj_3R_486()) jj_scanpos = xsp;
33109 xsp = jj_scanpos;
33110 if (jj_3R_487()) jj_scanpos = xsp;
33111 return false;
33112 }
33113
33114 private boolean jj_3R_613() {
33115 if (jj_3R_172()) return true;
33116 return false;
33117 }
33118
33119 private boolean jj_3R_151() {
33120 Token xsp;
33121 xsp = jj_scanpos;
33122 if (jj_3R_241()) {
33123 jj_scanpos = xsp;
33124 if (jj_3R_242()) return true;
33125 }
33126 if (jj_scan_token(4)) return true;
33127 return false;
33128 }
33129
33130 private boolean jj_3R_550() {
33131 if (jj_scan_token(LIMIT)) return true;
33132 if (jj_3R_232()) return true;
33133 return false;
33134 }
33135
33136 private boolean jj_3R_628() {
33137 if (jj_scan_token(6)) return true;
33138 if (jj_3R_232()) return true;
33139 return false;
33140 }
33141
33142 private boolean jj_3R_591() {
33143 if (jj_scan_token(CC_ELSE)) return true;
33144 Token xsp;
33145 if (jj_3R_613()) return true;
33146 while (true) {
33147 xsp = jj_scanpos;
33148 if (jj_3R_613()) { jj_scanpos = xsp; break; }
33149 }
33150 return false;
33151 }
33152
33153 private boolean jj_3R_590() {
33154 if (jj_scan_token(CC_ELSIF)) return true;
33155 if (jj_3R_342()) return true;
33156 if (jj_scan_token(CC_THEN)) return true;
33157 Token xsp;
33158 if (jj_3R_630()) return true;
33159 while (true) {
33160 xsp = jj_scanpos;
33161 if (jj_3R_630()) { jj_scanpos = xsp; break; }
33162 }
33163 return false;
33164 }
33165
33166 private boolean jj_3R_452() {
33167 if (jj_scan_token(CC_ERROR)) return true;
33168 if (jj_3R_232()) return true;
33169 if (jj_scan_token(CC_END)) return true;
33170 return false;
33171 }
33172
33173 private boolean jj_3R_451() {
33174 if (jj_scan_token(CC_IF)) return true;
33175 if (jj_3R_342()) return true;
33176 if (jj_scan_token(CC_THEN)) return true;
33177 Token xsp;
33178 while (true) {
33179 xsp = jj_scanpos;
33180 if (jj_3R_589()) { jj_scanpos = xsp; break; }
33181 }
33182 while (true) {
33183 xsp = jj_scanpos;
33184 if (jj_3R_590()) { jj_scanpos = xsp; break; }
33185 }
33186 while (true) {
33187 xsp = jj_scanpos;
33188 if (jj_3R_591()) { jj_scanpos = xsp; break; }
33189 }
33190 if (jj_scan_token(CC_END)) return true;
33191 return false;
33192 }
33193
33194 private boolean jj_3R_624() {
33195 if (jj_scan_token(6)) return true;
33196 if (jj_3R_293()) return true;
33197 return false;
33198 }
33199
33200 private boolean jj_3R_416() {
33201 Token xsp;
33202 xsp = jj_scanpos;
33203 if (jj_3R_451()) {
33204 jj_scanpos = xsp;
33205 if (jj_3R_452()) return true;
33206 }
33207 return false;
33208 }
33209
33210 private boolean jj_3R_612() {
33211 if (jj_scan_token(IN)) return true;
33212 Token xsp;
33213 xsp = jj_scanpos;
33214 if (jj_scan_token(204)) jj_scanpos = xsp;
33215 return false;
33216 }
33217
33218 private boolean jj_3R_588() {
33219 Token xsp;
33220 xsp = jj_scanpos;
33221 if (jj_3R_612()) {
33222 jj_scanpos = xsp;
33223 if (jj_scan_token(204)) return true;
33224 }
33225 return false;
33226 }
33227
33228 private boolean jj_3R_548() {
33229 if (jj_scan_token(BULK)) return true;
33230 if (jj_scan_token(COLLECT)) return true;
33231 return false;
33232 }
33233
33234 private boolean jj_3R_549() {
33235 if (jj_scan_token(6)) return true;
33236 if (jj_3R_232()) return true;
33237 return false;
33238 }
33239
33240 private boolean jj_3R_415() {
33241 if (jj_scan_token(PIPE)) return true;
33242 if (jj_scan_token(ROW)) return true;
33243 if (jj_3R_232()) return true;
33244 return false;
33245 }
33246
33247 private boolean jj_3R_587() {
33248 if (jj_scan_token(USING)) return true;
33249 if (jj_3R_232()) return true;
33250 Token xsp;
33251 while (true) {
33252 xsp = jj_scanpos;
33253 if (jj_3R_628()) { jj_scanpos = xsp; break; }
33254 }
33255 return false;
33256 }
33257
33258 private boolean jj_3R_553() {
33259 Token xsp;
33260 xsp = jj_scanpos;
33261 if (jj_scan_token(234)) {
33262 jj_scanpos = xsp;
33263 if (jj_scan_token(235)) return true;
33264 }
33265 if (jj_scan_token(INTO)) return true;
33266 if (jj_3R_232()) return true;
33267 while (true) {
33268 xsp = jj_scanpos;
33269 if (jj_3R_626()) { jj_scanpos = xsp; break; }
33270 }
33271 return false;
33272 }
33273
33274 private boolean jj_3R_552() {
33275 if (jj_scan_token(USING)) return true;
33276 Token xsp;
33277 xsp = jj_scanpos;
33278 if (jj_3R_588()) jj_scanpos = xsp;
33279 if (jj_3R_232()) return true;
33280 while (true) {
33281 xsp = jj_scanpos;
33282 if (jj_3R_625()) { jj_scanpos = xsp; break; }
33283 }
33284 return false;
33285 }
33286
33287 private boolean jj_3R_551() {
33288 if (jj_scan_token(INTO)) return true;
33289 if (jj_3R_293()) return true;
33290 Token xsp;
33291 while (true) {
33292 xsp = jj_scanpos;
33293 if (jj_3R_624()) { jj_scanpos = xsp; break; }
33294 }
33295 return false;
33296 }
33297
33298 private boolean jj_3R_447() {
33299 if (jj_scan_token(WHEN)) return true;
33300 if (jj_3R_232()) return true;
33301 return false;
33302 }
33303
33304 private boolean jj_3R_414() {
33305 if (jj_scan_token(EXECUTE)) return true;
33306 if (jj_scan_token(IMMEDIATE)) return true;
33307 if (jj_3R_232()) return true;
33308 Token xsp;
33309 xsp = jj_scanpos;
33310 if (jj_3R_551()) jj_scanpos = xsp;
33311 xsp = jj_scanpos;
33312 if (jj_3R_552()) jj_scanpos = xsp;
33313 xsp = jj_scanpos;
33314 if (jj_3R_553()) jj_scanpos = xsp;
33315 if (jj_scan_token(4)) return true;
33316 return false;
33317 }
33318
33319 private boolean jj_3R_450() {
33320 if (jj_scan_token(FOR)) return true;
33321 if (jj_3R_232()) return true;
33322 Token xsp;
33323 xsp = jj_scanpos;
33324 if (jj_3R_587()) jj_scanpos = xsp;
33325 return false;
33326 }
33327
33328 private boolean jj_3R_413() {
33329 if (jj_scan_token(FETCH)) return true;
33330 if (jj_3R_127()) return true;
33331 Token xsp;
33332 xsp = jj_scanpos;
33333 if (jj_3R_548()) jj_scanpos = xsp;
33334 if (jj_scan_token(INTO)) return true;
33335 if (jj_3R_232()) return true;
33336 while (true) {
33337 xsp = jj_scanpos;
33338 if (jj_3R_549()) { jj_scanpos = xsp; break; }
33339 }
33340 xsp = jj_scanpos;
33341 if (jj_3R_550()) jj_scanpos = xsp;
33342 return false;
33343 }
33344
33345 private boolean jj_3R_207() {
33346 if (jj_scan_token(WHEN)) return true;
33347 if (jj_3R_232()) return true;
33348 return false;
33349 }
33350
33351 private boolean jj_3R_449() {
33352 if (jj_3R_232()) return true;
33353 return false;
33354 }
33355
33356 private boolean jj_3R_412() {
33357 if (jj_scan_token(OPEN)) return true;
33358 Token xsp;
33359 xsp = jj_scanpos;
33360 if (jj_3R_449()) jj_scanpos = xsp;
33361 xsp = jj_scanpos;
33362 if (jj_3R_450()) jj_scanpos = xsp;
33363 return false;
33364 }
33365
33366 private boolean jj_3R_399() {
33367 if (jj_scan_token(INTERFACE)) return true;
33368 if (jj_scan_token(5)) return true;
33369 return false;
33370 }
33371
33372 private boolean jj_3R_398() {
33373 if (jj_scan_token(EXCEPTION_INIT)) return true;
33374 if (jj_scan_token(5)) return true;
33375 return false;
33376 }
33377
33378 private boolean jj_3R_397() {
33379 if (jj_scan_token(RESTRICT_REFERENCES)) return true;
33380 if (jj_scan_token(5)) return true;
33381 return false;
33382 }
33383
33384 private boolean jj_3R_448() {
33385 if (jj_3R_127()) return true;
33386 return false;
33387 }
33388
33389 private boolean jj_3R_411() {
33390 if (jj_scan_token(CLOSE)) return true;
33391 if (jj_3R_127()) return true;
33392 return false;
33393 }
33394
33395 private boolean jj_3R_446() {
33396 if (jj_3R_141()) return true;
33397 return false;
33398 }
33399
33400 private boolean jj_3R_410() {
33401 if (jj_scan_token(RAISE)) return true;
33402 Token xsp;
33403 xsp = jj_scanpos;
33404 if (jj_3R_448()) jj_scanpos = xsp;
33405 return false;
33406 }
33407
33408 private boolean jj_3R_206() {
33409 if (jj_3R_141()) return true;
33410 return false;
33411 }
33412
33413 private boolean jj_3R_349() {
33414 if (jj_scan_token(PRAGMA)) return true;
33415 Token xsp;
33416 xsp = jj_scanpos;
33417 if (jj_scan_token(38)) {
33418 jj_scanpos = xsp;
33419 if (jj_scan_token(41)) {
33420 jj_scanpos = xsp;
33421 if (jj_3R_397()) {
33422 jj_scanpos = xsp;
33423 if (jj_3R_398()) {
33424 jj_scanpos = xsp;
33425 if (jj_3R_399()) return true;
33426 }
33427 }
33428 }
33429 }
33430 return false;
33431 }
33432
33433 private boolean jj_3R_586() {
33434 if (jj_scan_token(12)) return true;
33435 if (jj_3R_232()) return true;
33436 return false;
33437 }
33438
33439 private boolean jj_3R_409() {
33440 if (jj_scan_token(EXIT)) return true;
33441 Token xsp;
33442 xsp = jj_scanpos;
33443 if (jj_3R_446()) jj_scanpos = xsp;
33444 xsp = jj_scanpos;
33445 if (jj_3R_447()) jj_scanpos = xsp;
33446 return false;
33447 }
33448
33449 private boolean jj_3R_445() {
33450 if (jj_3R_232()) return true;
33451 return false;
33452 }
33453
33454 private boolean jj_3R_131() {
33455 if (jj_scan_token(CONTINUE)) return true;
33456 Token xsp;
33457 xsp = jj_scanpos;
33458 if (jj_3R_206()) jj_scanpos = xsp;
33459 xsp = jj_scanpos;
33460 if (jj_3R_207()) jj_scanpos = xsp;
33461 return false;
33462 }
33463
33464 private boolean jj_3R_546() {
33465 if (jj_scan_token(SAVE)) return true;
33466 if (jj_scan_token(EXCEPTIONS)) return true;
33467 return false;
33468 }
33469
33470 private boolean jj_3R_545() {
33471 if (jj_3R_232()) return true;
33472 Token xsp;
33473 xsp = jj_scanpos;
33474 if (jj_3R_586()) jj_scanpos = xsp;
33475 return false;
33476 }
33477
33478 private boolean jj_3R_623() {
33479 if (jj_3R_172()) return true;
33480 return false;
33481 }
33482
33483 private boolean jj_3R_544() {
33484 Token xsp;
33485 xsp = jj_scanpos;
33486 if (jj_scan_token(138)) {
33487 jj_scanpos = xsp;
33488 if (jj_scan_token(286)) return true;
33489 }
33490 if (jj_scan_token(OF)) return true;
33491 if (jj_3R_232()) return true;
33492 return false;
33493 }
33494
33495 private boolean jj_3R_408() {
33496 if (jj_scan_token(RETURN)) return true;
33497 Token xsp;
33498 xsp = jj_scanpos;
33499 if (jj_3R_445()) jj_scanpos = xsp;
33500 return false;
33501 }
33502
33503 private boolean jj_3R_146() {
33504 if (jj_3R_123()) return true;
33505 if (jj_3R_234()) return true;
33506 return false;
33507 }
33508
33509 private boolean jj_3R_407() {
33510 if (jj_scan_token(GOTO)) return true;
33511 if (jj_3R_127()) return true;
33512 return false;
33513 }
33514
33515 private boolean jj_3R_404() {
33516 if (jj_scan_token(FORALL)) return true;
33517 if (jj_3R_443()) return true;
33518 if (jj_scan_token(IN)) return true;
33519 Token xsp;
33520 xsp = jj_scanpos;
33521 if (jj_3R_544()) {
33522 jj_scanpos = xsp;
33523 if (jj_3R_545()) return true;
33524 }
33525 xsp = jj_scanpos;
33526 if (jj_3R_546()) jj_scanpos = xsp;
33527 if (jj_3R_400()) return true;
33528 return false;
33529 }
33530
33531 private boolean jj_3R_543() {
33532 if (jj_scan_token(12)) return true;
33533 if (jj_3R_232()) return true;
33534 return false;
33535 }
33536
33537 private boolean jj_3R_540() {
33538 if (jj_3R_172()) return true;
33539 return false;
33540 }
33541
33542 private boolean jj_3R_547() {
33543 if (jj_3R_172()) return true;
33544 return false;
33545 }
33546
33547 private boolean jj_3R_443() {
33548 if (jj_3R_123()) return true;
33549 return false;
33550 }
33551
33552 private boolean jj_3R_442() {
33553 if (jj_3R_123()) return true;
33554 return false;
33555 }
33556
33557 private boolean jj_3R_542() {
33558 if (jj_3R_480()) return true;
33559 return false;
33560 }
33561
33562 private boolean jj_3R_541() {
33563 if (jj_3R_585()) return true;
33564 return false;
33565 }
33566
33567 private boolean jj_3R_402() {
33568 if (jj_scan_token(IF)) return true;
33569 if (jj_3R_232()) return true;
33570 if (jj_scan_token(THEN)) return true;
33571 Token xsp;
33572 if (jj_3R_540()) return true;
33573 while (true) {
33574 xsp = jj_scanpos;
33575 if (jj_3R_540()) { jj_scanpos = xsp; break; }
33576 }
33577 while (true) {
33578 xsp = jj_scanpos;
33579 if (jj_3R_541()) { jj_scanpos = xsp; break; }
33580 }
33581 xsp = jj_scanpos;
33582 if (jj_3R_542()) jj_scanpos = xsp;
33583 if (jj_scan_token(END)) return true;
33584 if (jj_scan_token(IF)) return true;
33585 return false;
33586 }
33587
33588 private boolean jj_3R_353() {
33589 if (jj_scan_token(CASCADE)) return true;
33590 return false;
33591 }
33592
33593 private boolean jj_3R_627() {
33594 if (jj_3R_172()) return true;
33595 return false;
33596 }
33597
33598 private boolean jj_3R_313() {
33599 Token xsp;
33600 xsp = jj_scanpos;
33601 if (jj_scan_token(149)) {
33602 jj_scanpos = xsp;
33603 if (jj_3R_353()) return true;
33604 }
33605 return false;
33606 }
33607
33608 private boolean jj_3R_130() {
33609 if (jj_scan_token(LOCK)) return true;
33610 if (jj_scan_token(TABLE)) return true;
33611 return false;
33612 }
33613
33614 private boolean jj_3R_406() {
33615 if (jj_scan_token(WHILE)) return true;
33616 if (jj_3R_232()) return true;
33617 if (jj_scan_token(LOOP)) return true;
33618 Token xsp;
33619 if (jj_3R_547()) return true;
33620 while (true) {
33621 xsp = jj_scanpos;
33622 if (jj_3R_547()) { jj_scanpos = xsp; break; }
33623 }
33624 if (jj_scan_token(END)) return true;
33625 if (jj_scan_token(LOOP)) return true;
33626 xsp = jj_scanpos;
33627 if (jj_scan_token(417)) jj_scanpos = xsp;
33628 return false;
33629 }
33630
33631 private boolean jj_3R_148() {
33632 if (jj_3R_237()) return true;
33633 return false;
33634 }
33635
33636 private boolean jj_3_71() {
33637 if (jj_3R_145()) return true;
33638 return false;
33639 }
33640
33641 private boolean jj_3R_147() {
33642 if (jj_scan_token(AUTHID)) return true;
33643 Token xsp;
33644 xsp = jj_scanpos;
33645 if (jj_scan_token(37)) {
33646 jj_scanpos = xsp;
33647 if (jj_scan_token(36)) return true;
33648 }
33649 return false;
33650 }
33651
33652 private boolean jj_3R_403() {
33653 if (jj_scan_token(FOR)) return true;
33654 if (jj_3R_442()) return true;
33655 if (jj_scan_token(IN)) return true;
33656 Token xsp;
33657 xsp = jj_scanpos;
33658 if (jj_scan_token(236)) jj_scanpos = xsp;
33659 if (jj_3R_232()) return true;
33660 xsp = jj_scanpos;
33661 if (jj_3R_543()) jj_scanpos = xsp;
33662 if (jj_scan_token(LOOP)) return true;
33663 if (jj_3R_623()) return true;
33664 while (true) {
33665 xsp = jj_scanpos;
33666 if (jj_3R_623()) { jj_scanpos = xsp; break; }
33667 }
33668 if (jj_scan_token(END)) return true;
33669 if (jj_scan_token(LOOP)) return true;
33670 xsp = jj_scanpos;
33671 if (jj_scan_token(417)) jj_scanpos = xsp;
33672 return false;
33673 }
33674
33675 private boolean jj_3R_610() {
33676 if (jj_3R_172()) return true;
33677 return false;
33678 }
33679
33680 private boolean jj_3R_444() {
33681 if (jj_3R_172()) return true;
33682 return false;
33683 }
33684
33685 private boolean jj_3R_312() {
33686 Token xsp;
33687 xsp = jj_scanpos;
33688 if (jj_scan_token(181)) jj_scanpos = xsp;
33689 xsp = jj_scanpos;
33690 if (jj_scan_token(118)) {
33691 jj_scanpos = xsp;
33692 if (jj_scan_token(143)) {
33693 jj_scanpos = xsp;
33694 if (jj_scan_token(183)) return true;
33695 }
33696 }
33697 return false;
33698 }
33699
33700 private boolean jj_3_70() {
33701 if (jj_3R_145()) return true;
33702 return false;
33703 }
33704
33705 private boolean jj_3R_405() {
33706 if (jj_scan_token(LOOP)) return true;
33707 Token xsp;
33708 if (jj_3R_444()) return true;
33709 while (true) {
33710 xsp = jj_scanpos;
33711 if (jj_3R_444()) { jj_scanpos = xsp; break; }
33712 }
33713 if (jj_scan_token(END)) return true;
33714 if (jj_scan_token(LOOP)) return true;
33715 xsp = jj_scanpos;
33716 if (jj_scan_token(417)) jj_scanpos = xsp;
33717 return false;
33718 }
33719
33720 private boolean jj_3R_129() {
33721 if (jj_scan_token(SET)) return true;
33722 if (jj_scan_token(TRANSACTION)) return true;
33723 return false;
33724 }
33725
33726 private boolean jj_3R_611() {
33727 if (jj_3R_172()) return true;
33728 return false;
33729 }
33730
33731 private boolean jj_3R_585() {
33732 if (jj_scan_token(ELSIF)) return true;
33733 if (jj_3R_232()) return true;
33734 if (jj_scan_token(THEN)) return true;
33735 Token xsp;
33736 if (jj_3R_627()) return true;
33737 while (true) {
33738 xsp = jj_scanpos;
33739 if (jj_3R_627()) { jj_scanpos = xsp; break; }
33740 }
33741 return false;
33742 }
33743
33744 private boolean jj_3_69() {
33745 Token xsp;
33746 xsp = jj_scanpos;
33747 if (jj_3R_147()) {
33748 jj_scanpos = xsp;
33749 if (jj_3R_148()) return true;
33750 }
33751 return false;
33752 }
33753
33754 private boolean jj_3R_311() {
33755 if (jj_scan_token(REPLACE)) return true;
33756 return false;
33757 }
33758
33759 private boolean jj_3R_480() {
33760 if (jj_scan_token(ELSE)) return true;
33761 Token xsp;
33762 if (jj_3R_611()) return true;
33763 while (true) {
33764 xsp = jj_scanpos;
33765 if (jj_3R_611()) { jj_scanpos = xsp; break; }
33766 }
33767 return false;
33768 }
33769
33770 private boolean jj_3R_479() {
33771 if (jj_scan_token(WHEN)) return true;
33772 if (jj_3R_232()) return true;
33773 if (jj_scan_token(THEN)) return true;
33774 Token xsp;
33775 if (jj_3R_610()) return true;
33776 while (true) {
33777 xsp = jj_scanpos;
33778 if (jj_3R_610()) { jj_scanpos = xsp; break; }
33779 }
33780 return false;
33781 }
33782
33783 private boolean jj_3R_439() {
33784 if (jj_3R_232()) return true;
33785 return false;
33786 }
33787
33788 private boolean jj_3R_441() {
33789 if (jj_3R_480()) return true;
33790 return false;
33791 }
33792
33793 private boolean jj_3R_440() {
33794 if (jj_3R_479()) return true;
33795 return false;
33796 }
33797
33798 private boolean jj_3R_401() {
33799 if (jj_scan_token(CASE)) return true;
33800 Token xsp;
33801 xsp = jj_scanpos;
33802 if (jj_3R_439()) jj_scanpos = xsp;
33803 while (true) {
33804 xsp = jj_scanpos;
33805 if (jj_3R_440()) { jj_scanpos = xsp; break; }
33806 }
33807 xsp = jj_scanpos;
33808 if (jj_3R_441()) jj_scanpos = xsp;
33809 if (jj_scan_token(END)) return true;
33810 if (jj_scan_token(CASE)) return true;
33811 xsp = jj_scanpos;
33812 if (jj_scan_token(417)) jj_scanpos = xsp;
33813 return false;
33814 }
33815
33816 private boolean jj_3R_354() {
33817 if (jj_3R_189()) return true;
33818 return false;
33819 }
33820
33821 private boolean jj_3R_314() {
33822 Token xsp;
33823 if (jj_3R_354()) return true;
33824 while (true) {
33825 xsp = jj_scanpos;
33826 if (jj_3R_354()) { jj_scanpos = xsp; break; }
33827 }
33828 if (jj_3R_315()) return true;
33829 return false;
33830 }
33831
33832 private boolean jj_3R_263() {
33833 if (jj_3R_315()) return true;
33834 return false;
33835 }
33836
33837 private boolean jj_3R_262() {
33838 if (jj_3R_314()) return true;
33839 return false;
33840 }
33841
33842 private boolean jj_3R_352() {
33843 if (jj_scan_token(DROP)) return true;
33844 return false;
33845 }
33846
33847 private boolean jj_3R_172() {
33848 Token xsp;
33849 xsp = jj_scanpos;
33850 if (jj_3R_262()) {
33851 jj_scanpos = xsp;
33852 if (jj_3R_263()) return true;
33853 }
33854 return false;
33855 }
33856
33857 private boolean jj_3R_373() {
33858 if (jj_3R_232()) return true;
33859 if (jj_scan_token(4)) return true;
33860 return false;
33861 }
33862
33863 private boolean jj_3R_372() {
33864 if (jj_3R_416()) return true;
33865 return false;
33866 }
33867
33868 private boolean jj_3R_371() {
33869 if (jj_3R_415()) return true;
33870 if (jj_scan_token(4)) return true;
33871 return false;
33872 }
33873
33874 private boolean jj_3R_438() {
33875 if (jj_scan_token(LOCK)) return true;
33876 if (jj_scan_token(TABLE)) return true;
33877 return false;
33878 }
33879
33880 private boolean jj_3R_370() {
33881 if (jj_3R_414()) return true;
33882 if (jj_scan_token(4)) return true;
33883 return false;
33884 }
33885
33886 private boolean jj_3R_369() {
33887 if (jj_3R_270()) return true;
33888 if (jj_scan_token(4)) return true;
33889 return false;
33890 }
33891
33892 private boolean jj_3R_368() {
33893 if (jj_3R_413()) return true;
33894 if (jj_scan_token(4)) return true;
33895 return false;
33896 }
33897
33898 private boolean jj_3R_367() {
33899 if (jj_3R_412()) return true;
33900 if (jj_scan_token(4)) return true;
33901 return false;
33902 }
33903
33904 private boolean jj_3R_366() {
33905 if (jj_3R_411()) return true;
33906 if (jj_scan_token(4)) return true;
33907 return false;
33908 }
33909
33910 private boolean jj_3R_365() {
33911 if (jj_3R_410()) return true;
33912 if (jj_scan_token(4)) return true;
33913 return false;
33914 }
33915
33916 private boolean jj_3R_364() {
33917 if (jj_3R_409()) return true;
33918 if (jj_scan_token(4)) return true;
33919 return false;
33920 }
33921
33922 private boolean jj_3R_363() {
33923 if (jj_3R_408()) return true;
33924 if (jj_scan_token(4)) return true;
33925 return false;
33926 }
33927
33928 private boolean jj_3R_362() {
33929 if (jj_3R_407()) return true;
33930 if (jj_scan_token(4)) return true;
33931 return false;
33932 }
33933
33934 private boolean jj_3_42() {
33935 Token xsp;
33936 xsp = jj_scanpos;
33937 if (jj_3R_128()) {
33938 jj_scanpos = xsp;
33939 if (jj_scan_token(294)) {
33940 jj_scanpos = xsp;
33941 if (jj_scan_token(142)) {
33942 jj_scanpos = xsp;
33943 if (jj_scan_token(92)) {
33944 jj_scanpos = xsp;
33945 if (jj_scan_token(75)) {
33946 jj_scanpos = xsp;
33947 if (jj_scan_token(238)) {
33948 jj_scanpos = xsp;
33949 if (jj_scan_token(245)) {
33950 jj_scanpos = xsp;
33951 if (jj_scan_token(110)) {
33952 jj_scanpos = xsp;
33953 if (jj_3R_129()) {
33954 jj_scanpos = xsp;
33955 if (jj_3R_130()) {
33956 jj_scanpos = xsp;
33957 if (jj_scan_token(163)) {
33958 jj_scanpos = xsp;
33959 if (jj_scan_token(315)) return true;
33960 }
33961 }
33962 }
33963 }
33964 }
33965 }
33966 }
33967 }
33968 }
33969 }
33970 }
33971 return false;
33972 }
33973
33974 private boolean jj_3R_128() {
33975 Token xsp;
33976 xsp = jj_scanpos;
33977 if (jj_scan_token(5)) jj_scanpos = xsp;
33978 if (jj_scan_token(SELECT)) return true;
33979 return false;
33980 }
33981
33982 private boolean jj_3R_361() {
33983 if (jj_3R_406()) return true;
33984 if (jj_scan_token(4)) return true;
33985 return false;
33986 }
33987
33988 private boolean jj_3R_360() {
33989 if (jj_3R_405()) return true;
33990 if (jj_scan_token(4)) return true;
33991 return false;
33992 }
33993
33994 private boolean jj_3R_359() {
33995 if (jj_3R_404()) return true;
33996 if (jj_scan_token(4)) return true;
33997 return false;
33998 }
33999
34000 private boolean jj_3R_358() {
34001 if (jj_3R_403()) return true;
34002 if (jj_scan_token(4)) return true;
34003 return false;
34004 }
34005
34006 private boolean jj_3R_357() {
34007 if (jj_3R_402()) return true;
34008 if (jj_scan_token(4)) return true;
34009 return false;
34010 }
34011
34012 private boolean jj_3R_356() {
34013 if (jj_3R_401()) return true;
34014 if (jj_scan_token(4)) return true;
34015 return false;
34016 }
34017
34018 private boolean jj_3R_351() {
34019 Token xsp;
34020 xsp = jj_scanpos;
34021 if (jj_scan_token(6)) jj_scanpos = xsp;
34022 xsp = jj_scanpos;
34023 if (jj_scan_token(43)) {
34024 jj_scanpos = xsp;
34025 if (jj_scan_token(168)) return true;
34026 }
34027 return false;
34028 }
34029
34030 private boolean jj_3R_310() {
34031 Token xsp;
34032 xsp = jj_scanpos;
34033 if (jj_3R_351()) {
34034 jj_scanpos = xsp;
34035 if (jj_3R_352()) return true;
34036 }
34037 return false;
34038 }
34039
34040 private boolean jj_3_43() {
34041 if (jj_3R_131()) return true;
34042 if (jj_scan_token(4)) return true;
34043 return false;
34044 }
34045
34046 private boolean jj_3R_355() {
34047 if (jj_3R_400()) return true;
34048 Token xsp;
34049 xsp = jj_scanpos;
34050 if (jj_scan_token(4)) jj_scanpos = xsp;
34051 return false;
34052 }
34053
34054 private boolean jj_3R_437() {
34055 if (jj_scan_token(SET)) return true;
34056 if (jj_scan_token(TRANSACTION)) return true;
34057 return false;
34058 }
34059
34060 private boolean jj_3R_315() {
34061 Token xsp;
34062 xsp = jj_scanpos;
34063 if (jj_3R_355()) {
34064 jj_scanpos = xsp;
34065 if (jj_3_43()) {
34066 jj_scanpos = xsp;
34067 if (jj_3R_356()) {
34068 jj_scanpos = xsp;
34069 if (jj_3R_357()) {
34070 jj_scanpos = xsp;
34071 if (jj_3R_358()) {
34072 jj_scanpos = xsp;
34073 if (jj_3R_359()) {
34074 jj_scanpos = xsp;
34075 if (jj_3R_360()) {
34076 jj_scanpos = xsp;
34077 if (jj_3R_361()) {
34078 jj_scanpos = xsp;
34079 if (jj_3R_362()) {
34080 jj_scanpos = xsp;
34081 if (jj_3R_363()) {
34082 jj_scanpos = xsp;
34083 if (jj_3R_364()) {
34084 jj_scanpos = xsp;
34085 if (jj_3R_365()) {
34086 jj_scanpos = xsp;
34087 if (jj_3R_366()) {
34088 jj_scanpos = xsp;
34089 if (jj_3R_367()) {
34090 jj_scanpos = xsp;
34091 if (jj_3R_368()) {
34092 jj_scanpos = xsp;
34093 if (jj_3R_369()) {
34094 jj_scanpos = xsp;
34095 if (jj_3R_370()) {
34096 jj_scanpos = xsp;
34097 if (jj_3R_371()) {
34098 jj_scanpos = xsp;
34099 if (jj_3R_372()) {
34100 jj_scanpos = xsp;
34101 if (jj_3R_373()) return true;
34102 }
34103 }
34104 }
34105 }
34106 }
34107 }
34108 }
34109 }
34110 }
34111 }
34112 }
34113 }
34114 }
34115 }
34116 }
34117 }
34118 }
34119 }
34120 }
34121 return false;
34122 }
34123
34124 private boolean jj_3R_306() {
34125 if (jj_3R_146()) return true;
34126 return false;
34127 }
34128
34129 private boolean jj_3R_258() {
34130 if (jj_scan_token(ALTER)) return true;
34131 if (jj_scan_token(TYPE)) return true;
34132 if (jj_3R_127()) return true;
34133 Token xsp;
34134 while (true) {
34135 xsp = jj_scanpos;
34136 if (jj_3R_310()) { jj_scanpos = xsp; break; }
34137 }
34138 xsp = jj_scanpos;
34139 if (jj_3R_311()) jj_scanpos = xsp;
34140 while (true) {
34141 xsp = jj_scanpos;
34142 if (jj_3R_312()) { jj_scanpos = xsp; break; }
34143 }
34144 xsp = jj_scanpos;
34145 if (jj_3R_313()) jj_scanpos = xsp;
34146 return false;
34147 }
34148
34149 private boolean jj_3_68() {
34150 if (jj_3R_146()) return true;
34151 return false;
34152 }
34153
34154 private boolean jj_3R_259() {
34155 if (jj_3R_258()) return true;
34156 return false;
34157 }
34158
34159 private boolean jj_3R_166() {
34160 Token xsp;
34161 xsp = jj_scanpos;
34162 if (jj_scan_token(4)) {
34163 jj_scanpos = xsp;
34164 if (jj_scan_token(1)) return true;
34165 }
34166 while (true) {
34167 xsp = jj_scanpos;
34168 if (jj_3R_259()) { jj_scanpos = xsp; break; }
34169 }
34170 return false;
34171 }
34172
34173 private boolean jj_3R_165() {
34174 if (jj_3R_258()) return true;
34175 return false;
34176 }
34177
34178 private boolean jj_3R_308() {
34179 if (jj_3R_145()) return true;
34180 return false;
34181 }
34182
34183 private boolean jj_3R_309() {
34184 if (jj_3R_349()) return true;
34185 return false;
34186 }
34187
34188 private boolean jj_3R_247() {
34189 if (jj_scan_token(WRAPPED)) return true;
34190 return false;
34191 }
34192
34193 private boolean jj_3R_164() {
34194 Token xsp;
34195 xsp = jj_scanpos;
34196 if (jj_scan_token(181)) jj_scanpos = xsp;
34197 xsp = jj_scanpos;
34198 if (jj_scan_token(118)) {
34199 jj_scanpos = xsp;
34200 if (jj_scan_token(143)) {
34201 jj_scanpos = xsp;
34202 if (jj_scan_token(183)) return true;
34203 }
34204 }
34205 return false;
34206 }
34207
34208 private boolean jj_3R_257() {
34209 if (jj_scan_token(6)) return true;
34210 Token xsp;
34211 xsp = jj_scanpos;
34212 if (jj_3R_308()) {
34213 jj_scanpos = xsp;
34214 if (jj_3_68()) {
34215 jj_scanpos = xsp;
34216 if (jj_3R_309()) return true;
34217 }
34218 }
34219 return false;
34220 }
34221
34222 private boolean jj_3R_307() {
34223 if (jj_3R_349()) return true;
34224 return false;
34225 }
34226
34227 private boolean jj_3_67() {
34228 if (jj_3R_145()) return true;
34229 return false;
34230 }
34231
34232 private boolean jj_3R_256() {
34233 Token xsp;
34234 xsp = jj_scanpos;
34235 if (jj_3_67()) {
34236 jj_scanpos = xsp;
34237 if (jj_3R_306()) {
34238 jj_scanpos = xsp;
34239 if (jj_3R_307()) return true;
34240 }
34241 }
34242 return false;
34243 }
34244
34245 private boolean jj_3R_163() {
34246 if (jj_scan_token(5)) return true;
34247 Token xsp;
34248 while (true) {
34249 xsp = jj_scanpos;
34250 if (jj_3R_256()) { jj_scanpos = xsp; break; }
34251 }
34252 while (true) {
34253 xsp = jj_scanpos;
34254 if (jj_3R_257()) { jj_scanpos = xsp; break; }
34255 }
34256 if (jj_scan_token(7)) return true;
34257 return false;
34258 }
34259
34260 private boolean jj_3R_599() {
34261 if (jj_3R_123()) return true;
34262 return false;
34263 }
34264
34265 private boolean jj_3R_162() {
34266 if (jj_3R_247()) return true;
34267 return false;
34268 }
34269
34270 private boolean jj_3_65() {
34271 Token xsp;
34272 xsp = jj_scanpos;
34273 if (jj_scan_token(150)) {
34274 jj_scanpos = xsp;
34275 if (jj_scan_token(50)) return true;
34276 }
34277 if (jj_3R_144()) return true;
34278 if (jj_scan_token(OF)) return true;
34279 if (jj_3R_234()) return true;
34280 return false;
34281 }
34282
34283 private boolean jj_3R_143() {
34284 if (jj_3R_237()) return true;
34285 return false;
34286 }
34287
34288 private boolean jj_3_64() {
34289 Token xsp;
34290 xsp = jj_scanpos;
34291 if (jj_scan_token(150)) {
34292 jj_scanpos = xsp;
34293 if (jj_scan_token(50)) return true;
34294 }
34295 if (jj_scan_token(OPAQUE)) return true;
34296 if (jj_scan_token(VARYING)) return true;
34297 if (jj_scan_token(24)) return true;
34298 return false;
34299 }
34300
34301 private boolean jj_3_66() {
34302 if (jj_scan_token(EXTERNAL)) return true;
34303 if (jj_scan_token(IDENTIFIER)) return true;
34304 if (jj_scan_token(IDENTIFIER)) return true;
34305 if (jj_scan_token(LANGUAGE)) return true;
34306 if (jj_scan_token(JAVA)) return true;
34307 if (jj_scan_token(USING)) return true;
34308 if (jj_scan_token(IDENTIFIER)) return true;
34309 return false;
34310 }
34311
34312 private boolean jj_3_63() {
34313 Token xsp;
34314 xsp = jj_scanpos;
34315 if (jj_scan_token(150)) {
34316 jj_scanpos = xsp;
34317 if (jj_scan_token(50)) return true;
34318 }
34319 if (jj_scan_token(OBJECT)) return true;
34320 return false;
34321 }
34322
34323 private boolean jj_3R_142() {
34324 if (jj_scan_token(AUTHID)) return true;
34325 Token xsp;
34326 xsp = jj_scanpos;
34327 if (jj_scan_token(37)) {
34328 jj_scanpos = xsp;
34329 if (jj_scan_token(36)) return true;
34330 }
34331 return false;
34332 }
34333
34334 private boolean jj_3R_255() {
34335 if (jj_scan_token(UNDER)) return true;
34336 if (jj_3R_153()) return true;
34337 return false;
34338 }
34339
34340 private boolean jj_3R_161() {
34341 Token xsp;
34342 xsp = jj_scanpos;
34343 if (jj_3R_255()) {
34344 jj_scanpos = xsp;
34345 if (jj_3_63()) {
34346 jj_scanpos = xsp;
34347 if (jj_3_64()) {
34348 jj_scanpos = xsp;
34349 if (jj_3_65()) return true;
34350 }
34351 }
34352 }
34353 return false;
34354 }
34355
34356 private boolean jj_3R_254() {
34357 Token xsp;
34358 xsp = jj_scanpos;
34359 if (jj_scan_token(99)) {
34360 jj_scanpos = xsp;
34361 if (jj_scan_token(180)) return true;
34362 }
34363 return false;
34364 }
34365
34366 private boolean jj_3R_598() {
34367 if (jj_3R_348()) return true;
34368 return false;
34369 }
34370
34371 private boolean jj_3_62() {
34372 Token xsp;
34373 xsp = jj_scanpos;
34374 if (jj_3R_142()) {
34375 jj_scanpos = xsp;
34376 if (jj_3R_143()) return true;
34377 }
34378 return false;
34379 }
34380
34381 private boolean jj_3R_400() {
34382 Token xsp;
34383 xsp = jj_scanpos;
34384 if (jj_scan_token(247)) {
34385 jj_scanpos = xsp;
34386 if (jj_scan_token(294)) {
34387 jj_scanpos = xsp;
34388 if (jj_scan_token(142)) {
34389 jj_scanpos = xsp;
34390 if (jj_scan_token(92)) {
34391 jj_scanpos = xsp;
34392 if (jj_scan_token(75)) {
34393 jj_scanpos = xsp;
34394 if (jj_scan_token(238)) {
34395 jj_scanpos = xsp;
34396 if (jj_scan_token(245)) {
34397 jj_scanpos = xsp;
34398 if (jj_scan_token(110)) {
34399 jj_scanpos = xsp;
34400 if (jj_3R_437()) {
34401 jj_scanpos = xsp;
34402 if (jj_3R_438()) {
34403 jj_scanpos = xsp;
34404 if (jj_scan_token(163)) {
34405 jj_scanpos = xsp;
34406 if (jj_scan_token(315)) return true;
34407 }
34408 }
34409 }
34410 }
34411 }
34412 }
34413 }
34414 }
34415 }
34416 }
34417 }
34418 if (jj_3R_178()) return true;
34419 return false;
34420 }
34421
34422 private boolean jj_3_61() {
34423 if (jj_scan_token(OID)) return true;
34424 if (jj_scan_token(STRING_LITERAL)) return true;
34425 return false;
34426 }
34427
34428 private boolean jj_3R_485() {
34429 return false;
34430 }
34431
34432 private boolean jj_3R_253() {
34433 if (jj_scan_token(OR)) return true;
34434 if (jj_scan_token(REPLACE)) return true;
34435 return false;
34436 }
34437
34438 private boolean jj_3R_597() {
34439 if (jj_3R_172()) return true;
34440 return false;
34441 }
34442
34443 private boolean jj_3R_160() {
34444 if (jj_scan_token(CREATE)) return true;
34445 Token xsp;
34446 xsp = jj_scanpos;
34447 if (jj_3R_253()) jj_scanpos = xsp;
34448 xsp = jj_scanpos;
34449 if (jj_3R_254()) jj_scanpos = xsp;
34450 return false;
34451 }
34452
34453 private boolean jj_3R_104() {
34454 Token xsp;
34455 xsp = jj_scanpos;
34456 if (jj_3R_160()) jj_scanpos = xsp;
34457 if (jj_scan_token(TYPE)) return true;
34458 if (jj_3R_153()) return true;
34459 xsp = jj_scanpos;
34460 if (jj_scan_token(122)) jj_scanpos = xsp;
34461 xsp = jj_scanpos;
34462 if (jj_3_61()) jj_scanpos = xsp;
34463 while (true) {
34464 xsp = jj_scanpos;
34465 if (jj_3_62()) { jj_scanpos = xsp; break; }
34466 }
34467 xsp = jj_scanpos;
34468 if (jj_3R_161()) jj_scanpos = xsp;
34469 xsp = jj_scanpos;
34470 if (jj_3_66()) jj_scanpos = xsp;
34471 xsp = jj_scanpos;
34472 if (jj_3R_162()) jj_scanpos = xsp;
34473 xsp = jj_scanpos;
34474 if (jj_3R_163()) jj_scanpos = xsp;
34475 while (true) {
34476 xsp = jj_scanpos;
34477 if (jj_3R_164()) { jj_scanpos = xsp; break; }
34478 }
34479 while (true) {
34480 xsp = jj_scanpos;
34481 if (jj_3R_165()) { jj_scanpos = xsp; break; }
34482 }
34483 xsp = jj_scanpos;
34484 if (jj_3R_166()) jj_scanpos = xsp;
34485 return false;
34486 }
34487
34488 private boolean jj_3R_562() {
34489 if (jj_3R_190()) return true;
34490 if (jj_scan_token(BEGIN)) return true;
34491 Token xsp;
34492 while (true) {
34493 xsp = jj_scanpos;
34494 if (jj_3R_597()) { jj_scanpos = xsp; break; }
34495 }
34496 xsp = jj_scanpos;
34497 if (jj_3R_598()) jj_scanpos = xsp;
34498 if (jj_scan_token(END)) return true;
34499 xsp = jj_scanpos;
34500 if (jj_3R_599()) jj_scanpos = xsp;
34501 if (jj_scan_token(4)) return true;
34502 return false;
34503 }
34504
34505 private boolean jj_3R_561() {
34506 if (jj_3R_122()) return true;
34507 Token xsp;
34508 xsp = jj_scanpos;
34509 if (jj_scan_token(4)) jj_scanpos = xsp;
34510 return false;
34511 }
34512
34513 private boolean jj_3R_525() {
34514 Token xsp;
34515 xsp = jj_scanpos;
34516 if (jj_scan_token(150)) {
34517 jj_scanpos = xsp;
34518 if (jj_scan_token(50)) return true;
34519 }
34520 xsp = jj_scanpos;
34521 if (jj_3R_561()) {
34522 jj_scanpos = xsp;
34523 if (jj_3R_562()) return true;
34524 }
34525 return false;
34526 }
34527
34528 private boolean jj_3R_186() {
34529 return false;
34530 }
34531
34532 private boolean jj_3_59() {
34533 if (jj_3R_123()) return true;
34534 if (jj_scan_token(3)) return true;
34535 return false;
34536 }
34537
34538 private boolean jj_3R_188() {
34539 return false;
34540 }
34541
34542 private boolean jj_3R_240() {
34543 Token xsp;
34544 xsp = jj_scanpos;
34545 if (jj_scan_token(160)) {
34546 jj_scanpos = xsp;
34547 if (jj_scan_token(201)) return true;
34548 }
34549 return false;
34550 }
34551
34552 private boolean jj_3R_239() {
34553 Token xsp;
34554 xsp = jj_scanpos;
34555 if (jj_scan_token(181)) jj_scanpos = xsp;
34556 xsp = jj_scanpos;
34557 if (jj_scan_token(205)) {
34558 jj_scanpos = xsp;
34559 if (jj_scan_token(143)) {
34560 jj_scanpos = xsp;
34561 if (jj_scan_token(118)) return true;
34562 }
34563 }
34564 return false;
34565 }
34566
34567 private boolean jj_3_60() {
34568 if (jj_3R_123()) return true;
34569 if (jj_scan_token(3)) return true;
34570 if (jj_3R_123()) return true;
34571 if (jj_scan_token(3)) return true;
34572 if (jj_3R_123()) return true;
34573 return false;
34574 }
34575
34576 private boolean jj_3R_145() {
34577 Token xsp;
34578 while (true) {
34579 xsp = jj_scanpos;
34580 if (jj_3R_239()) { jj_scanpos = xsp; break; }
34581 }
34582 xsp = jj_scanpos;
34583 if (jj_3R_240()) jj_scanpos = xsp;
34584 xsp = jj_scanpos;
34585 if (jj_scan_token(79)) {
34586 jj_scanpos = xsp;
34587 if (jj_scan_token(162)) {
34588 jj_scanpos = xsp;
34589 if (jj_scan_token(259)) return true;
34590 }
34591 }
34592 if (jj_3R_192()) return true;
34593 xsp = jj_scanpos;
34594 if (jj_scan_token(94)) jj_scanpos = xsp;
34595 xsp = jj_scanpos;
34596 if (jj_scan_token(207)) jj_scanpos = xsp;
34597 xsp = jj_scanpos;
34598 if (jj_scan_token(211)) jj_scanpos = xsp;
34599 xsp = jj_scanpos;
34600 if (jj_scan_token(233)) jj_scanpos = xsp;
34601 xsp = jj_scanpos;
34602 if (jj_3R_525()) jj_scanpos = xsp;
34603 return false;
34604 }
34605
34606 private boolean jj_3R_454() {
34607 if (jj_3R_172()) return true;
34608 return false;
34609 }
34610
34611 private boolean jj_3R_260() {
34612 if (jj_3R_123()) return true;
34613 return false;
34614 }
34615
34616 private boolean jj_3R_558() {
34617 return false;
34618 }
34619
34620 private boolean jj_3R_183() {
34621 if (jj_3R_141()) return true;
34622 if (jj_scan_token(IDENTIFIED)) return true;
34623 return false;
34624 }
34625
34626 private boolean jj_3R_453() {
34627 if (jj_scan_token(OR)) return true;
34628 if (jj_3R_127()) return true;
34629 return false;
34630 }
34631
34632 private boolean jj_3R_455() {
34633 if (jj_3R_172()) return true;
34634 return false;
34635 }
34636
34637 private boolean jj_3R_182() {
34638 if (jj_scan_token(CONNECT)) return true;
34639 if (jj_scan_token(TO)) return true;
34640 return false;
34641 }
34642
34643 private boolean jj_3R_111() {
34644 if (jj_scan_token(CREATE)) return true;
34645 Token xsp;
34646 xsp = jj_scanpos;
34647 if (jj_scan_token(407)) jj_scanpos = xsp;
34648 xsp = jj_scanpos;
34649 if (jj_scan_token(221)) jj_scanpos = xsp;
34650 if (jj_scan_token(DATABASE)) return true;
34651 if (jj_scan_token(LINK)) return true;
34652 if (jj_3R_153()) return true;
34653 xsp = jj_scanpos;
34654 if (jj_3R_182()) {
34655 jj_scanpos = xsp;
34656 if (jj_3R_183()) return true;
34657 }
34658 return false;
34659 }
34660
34661 private boolean jj_3R_180() {
34662 if (jj_scan_token(OR)) return true;
34663 if (jj_scan_token(REPLACE)) return true;
34664 return false;
34665 }
34666
34667 private boolean jj_3R_178() {
34668 return false;
34669 }
34670
34671 private boolean jj_3R_110() {
34672 if (jj_scan_token(CREATE)) return true;
34673 Token xsp;
34674 xsp = jj_scanpos;
34675 if (jj_3R_180()) jj_scanpos = xsp;
34676 if (jj_scan_token(DIRECTORY)) return true;
34677 if (jj_3R_153()) return true;
34678 if (jj_scan_token(AS)) return true;
34679 if (jj_3R_181()) return true;
34680 xsp = jj_scanpos;
34681 if (jj_scan_token(4)) {
34682 jj_scanpos = xsp;
34683 if (jj_scan_token(1)) return true;
34684 }
34685 return false;
34686 }
34687
34688 private boolean jj_3R_417() {
34689 if (jj_scan_token(WHEN)) return true;
34690 if (jj_scan_token(OTHERS)) return true;
34691 if (jj_scan_token(THEN)) return true;
34692 Token xsp;
34693 if (jj_3R_455()) return true;
34694 while (true) {
34695 xsp = jj_scanpos;
34696 if (jj_3R_455()) { jj_scanpos = xsp; break; }
34697 }
34698 return false;
34699 }
34700
34701 private boolean jj_3_41() {
34702 if (jj_scan_token(WHEN)) return true;
34703 if (jj_3R_127()) return true;
34704 Token xsp;
34705 while (true) {
34706 xsp = jj_scanpos;
34707 if (jj_3R_453()) { jj_scanpos = xsp; break; }
34708 }
34709 if (jj_scan_token(THEN)) return true;
34710 if (jj_3R_454()) return true;
34711 while (true) {
34712 xsp = jj_scanpos;
34713 if (jj_3R_454()) { jj_scanpos = xsp; break; }
34714 }
34715 return false;
34716 }
34717
34718 private boolean jj_3R_179() {
34719 if (jj_scan_token(OR)) return true;
34720 if (jj_scan_token(REPLACE)) return true;
34721 return false;
34722 }
34723
34724 private boolean jj_3R_261() {
34725 if (jj_scan_token(6)) return true;
34726 return false;
34727 }
34728
34729 private boolean jj_3R_109() {
34730 if (jj_scan_token(CREATE)) return true;
34731 Token xsp;
34732 xsp = jj_scanpos;
34733 if (jj_3R_179()) jj_scanpos = xsp;
34734 xsp = jj_scanpos;
34735 if (jj_scan_token(221)) jj_scanpos = xsp;
34736 if (jj_scan_token(SYNONYM)) return true;
34737 if (jj_3R_153()) return true;
34738 if (jj_scan_token(FOR)) return true;
34739 if (jj_3R_153()) return true;
34740 xsp = jj_scanpos;
34741 if (jj_scan_token(4)) {
34742 jj_scanpos = xsp;
34743 if (jj_scan_token(1)) return true;
34744 }
34745 return false;
34746 }
34747
34748 private boolean jj_3R_348() {
34749 if (jj_scan_token(EXCEPTION)) return true;
34750 Token xsp;
34751 while (true) {
34752 xsp = jj_scanpos;
34753 if (jj_3_41()) { jj_scanpos = xsp; break; }
34754 }
34755 xsp = jj_scanpos;
34756 if (jj_3R_417()) jj_scanpos = xsp;
34757 return false;
34758 }
34759
34760 private boolean jj_3R_169() {
34761 if (jj_scan_token(OR)) return true;
34762 if (jj_scan_token(REPLACE)) return true;
34763 return false;
34764 }
34765
34766 private boolean jj_3_40() {
34767 if (jj_scan_token(5)) return true;
34768 if (jj_3R_126()) return true;
34769 if (jj_scan_token(7)) return true;
34770 return false;
34771 }
34772
34773 private boolean jj_3R_171() {
34774 if (jj_scan_token(5)) return true;
34775 if (jj_3R_260()) return true;
34776 Token xsp;
34777 while (true) {
34778 xsp = jj_scanpos;
34779 if (jj_3R_261()) { jj_scanpos = xsp; break; }
34780 }
34781 if (jj_scan_token(7)) return true;
34782 return false;
34783 }
34784
34785 private boolean jj_3R_170() {
34786 Token xsp;
34787 xsp = jj_scanpos;
34788 if (jj_scan_token(177)) jj_scanpos = xsp;
34789 if (jj_scan_token(FORCE)) return true;
34790 return false;
34791 }
34792
34793 private boolean jj_3R_106() {
34794 if (jj_scan_token(CREATE)) return true;
34795 Token xsp;
34796 xsp = jj_scanpos;
34797 if (jj_3R_169()) jj_scanpos = xsp;
34798 xsp = jj_scanpos;
34799 if (jj_3R_170()) jj_scanpos = xsp;
34800 if (jj_scan_token(VIEW)) return true;
34801 if (jj_3R_153()) return true;
34802 xsp = jj_scanpos;
34803 if (jj_3R_171()) jj_scanpos = xsp;
34804 if (jj_scan_token(AS)) return true;
34805 if (jj_3R_172()) return true;
34806 xsp = jj_scanpos;
34807 if (jj_scan_token(4)) {
34808 jj_scanpos = xsp;
34809 if (jj_scan_token(1)) return true;
34810 }
34811 return false;
34812 }
34813
34814 private boolean jj_3R_475() {
34815 if (jj_scan_token(TO)) return true;
34816 Token xsp;
34817 xsp = jj_scanpos;
34818 if (jj_scan_token(313)) {
34819 jj_scanpos = xsp;
34820 if (jj_scan_token(171)) {
34821 jj_scanpos = xsp;
34822 if (jj_scan_token(88)) {
34823 jj_scanpos = xsp;
34824 if (jj_scan_token(132)) {
34825 jj_scanpos = xsp;
34826 if (jj_scan_token(166)) {
34827 jj_scanpos = xsp;
34828 if (jj_scan_token(246)) return true;
34829 }
34830 }
34831 }
34832 }
34833 }
34834 xsp = jj_scanpos;
34835 if (jj_3_40()) jj_scanpos = xsp;
34836 return false;
34837 }
34838
34839 private boolean jj_3R_501() {
34840 if (jj_scan_token(LOCAL)) return true;
34841 return false;
34842 }
34843
34844 private boolean jj_3R_168() {
34845 if (jj_3R_123()) return true;
34846 if (jj_3R_234()) return true;
34847 return false;
34848 }
34849
34850 private boolean jj_3R_620() {
34851 if (jj_scan_token(6)) return true;
34852 if (jj_3R_123()) return true;
34853 return false;
34854 }
34855
34856 private boolean jj_3R_474() {
34857 if (jj_scan_token(WITH)) return true;
34858 Token xsp;
34859 xsp = jj_scanpos;
34860 if (jj_3R_501()) jj_scanpos = xsp;
34861 if (jj_scan_token(TIME)) return true;
34862 if (jj_scan_token(ZONE)) return true;
34863 return false;
34864 }
34865
34866 private boolean jj_3R_430() {
34867 Token xsp;
34868 xsp = jj_scanpos;
34869 if (jj_3R_474()) {
34870 jj_scanpos = xsp;
34871 if (jj_3R_475()) return true;
34872 }
34873 return false;
34874 }
34875
34876 private boolean jj_3R_619() {
34877 if (jj_scan_token(6)) return true;
34878 if (jj_3R_123()) return true;
34879 return false;
34880 }
34881
34882 private boolean jj_3_39() {
34883 if (jj_scan_token(5)) return true;
34884 if (jj_3R_126()) return true;
34885 if (jj_scan_token(7)) return true;
34886 return false;
34887 }
34888
34889 private boolean jj_3R_167() {
34890 if (jj_scan_token(GLOBAL)) return true;
34891 if (jj_scan_token(TEMPORARY)) return true;
34892 return false;
34893 }
34894
34895 private boolean jj_3_58() {
34896 if (jj_scan_token(ON)) return true;
34897 if (jj_scan_token(COMMIT)) return true;
34898 return false;
34899 }
34900
34901 private boolean jj_3R_105() {
34902 if (jj_scan_token(CREATE)) return true;
34903 Token xsp;
34904 xsp = jj_scanpos;
34905 if (jj_3R_167()) jj_scanpos = xsp;
34906 if (jj_scan_token(TABLE)) return true;
34907 if (jj_3R_153()) return true;
34908 if (jj_scan_token(5)) return true;
34909 if (jj_3R_168()) return true;
34910 return false;
34911 }
34912
34913 private boolean jj_3R_429() {
34914 Token xsp;
34915 xsp = jj_scanpos;
34916 if (jj_scan_token(313)) {
34917 jj_scanpos = xsp;
34918 if (jj_scan_token(171)) {
34919 jj_scanpos = xsp;
34920 if (jj_scan_token(88)) {
34921 jj_scanpos = xsp;
34922 if (jj_scan_token(132)) {
34923 jj_scanpos = xsp;
34924 if (jj_scan_token(166)) {
34925 jj_scanpos = xsp;
34926 if (jj_scan_token(246)) return true;
34927 }
34928 }
34929 }
34930 }
34931 }
34932 return false;
34933 }
34934
34935 private boolean jj_3R_428() {
34936 if (jj_3R_181()) return true;
34937 return false;
34938 }
34939
34940 private boolean jj_3R_484() {
34941 if (jj_scan_token(6)) return true;
34942 if (jj_3R_126()) return true;
34943 return false;
34944 }
34945
34946 private boolean jj_3R_427() {
34947 if (jj_scan_token(CHARACTER_LITERAL)) return true;
34948 return false;
34949 }
34950
34951 private boolean jj_3R_614() {
34952 Token xsp;
34953 xsp = jj_scanpos;
34954 if (jj_scan_token(124)) {
34955 jj_scanpos = xsp;
34956 if (jj_scan_token(220)) {
34957 jj_scanpos = xsp;
34958 if (jj_scan_token(206)) {
34959 jj_scanpos = xsp;
34960 if (jj_scan_token(279)) {
34961 jj_scanpos = xsp;
34962 if (jj_scan_token(281)) return true;
34963 }
34964 }
34965 }
34966 }
34967 return false;
34968 }
34969
34970 private boolean jj_3R_483() {
34971 Token xsp;
34972 xsp = jj_scanpos;
34973 if (jj_scan_token(16)) {
34974 jj_scanpos = xsp;
34975 if (jj_scan_token(17)) return true;
34976 }
34977 return false;
34978 }
34979
34980 private boolean jj_3R_347() {
34981 Token xsp;
34982 xsp = jj_scanpos;
34983 if (jj_scan_token(124)) {
34984 jj_scanpos = xsp;
34985 if (jj_scan_token(220)) {
34986 jj_scanpos = xsp;
34987 if (jj_scan_token(206)) {
34988 jj_scanpos = xsp;
34989 if (jj_scan_token(279)) {
34990 jj_scanpos = xsp;
34991 if (jj_scan_token(281)) return true;
34992 }
34993 }
34994 }
34995 }
34996 return false;
34997 }
34998
34999 private boolean jj_3R_594() {
35000 if (jj_scan_token(6)) return true;
35001 Token xsp;
35002 xsp = jj_scanpos;
35003 if (jj_3R_614()) jj_scanpos = xsp;
35004 if (jj_3R_127()) return true;
35005 return false;
35006 }
35007
35008 private boolean jj_3R_237() {
35009 if (jj_scan_token(ACCESSIBLE)) return true;
35010 if (jj_scan_token(BY)) return true;
35011 if (jj_scan_token(5)) return true;
35012 Token xsp;
35013 xsp = jj_scanpos;
35014 if (jj_3R_347()) jj_scanpos = xsp;
35015 if (jj_3R_127()) return true;
35016 while (true) {
35017 xsp = jj_scanpos;
35018 if (jj_3R_594()) { jj_scanpos = xsp; break; }
35019 }
35020 if (jj_scan_token(7)) return true;
35021 return false;
35022 }
35023
35024 private boolean jj_3R_615() {
35025 Token xsp;
35026 xsp = jj_scanpos;
35027 if (jj_scan_token(129)) {
35028 jj_scanpos = xsp;
35029 if (jj_scan_token(223)) return true;
35030 }
35031 if (jj_scan_token(5)) return true;
35032 if (jj_3R_123()) return true;
35033 while (true) {
35034 xsp = jj_scanpos;
35035 if (jj_3R_619()) { jj_scanpos = xsp; break; }
35036 }
35037 if (jj_scan_token(7)) return true;
35038 return false;
35039 }
35040
35041 private boolean jj_3R_616() {
35042 Token xsp;
35043 xsp = jj_scanpos;
35044 if (jj_scan_token(201)) {
35045 jj_scanpos = xsp;
35046 if (jj_scan_token(70)) return true;
35047 }
35048 if (jj_scan_token(BY)) return true;
35049 if (jj_scan_token(5)) return true;
35050 if (jj_3R_123()) return true;
35051 while (true) {
35052 xsp = jj_scanpos;
35053 if (jj_3R_620()) { jj_scanpos = xsp; break; }
35054 }
35055 if (jj_scan_token(7)) return true;
35056 return false;
35057 }
35058
35059 private boolean jj_3_34() {
35060 if (jj_scan_token(5)) return true;
35061 if (jj_3R_126()) return true;
35062 if (jj_scan_token(7)) return true;
35063 return false;
35064 }
35065
35066 private boolean jj_3R_389() {
35067 Token xsp;
35068 xsp = jj_scanpos;
35069 if (jj_scan_token(147)) {
35070 jj_scanpos = xsp;
35071 if (jj_scan_token(272)) {
35072 jj_scanpos = xsp;
35073 if (jj_scan_token(87)) return true;
35074 }
35075 }
35076 xsp = jj_scanpos;
35077 if (jj_3R_427()) {
35078 jj_scanpos = xsp;
35079 if (jj_3R_428()) return true;
35080 }
35081 xsp = jj_scanpos;
35082 if (jj_3R_429()) jj_scanpos = xsp;
35083 xsp = jj_scanpos;
35084 if (jj_3_39()) jj_scanpos = xsp;
35085 xsp = jj_scanpos;
35086 if (jj_3R_430()) jj_scanpos = xsp;
35087 return false;
35088 }
35089
35090 private boolean jj_3R_513() {
35091 if (jj_3R_181()) return true;
35092 return false;
35093 }
35094
35095 private boolean jj_3R_424() {
35096 if (jj_scan_token(5)) return true;
35097 if (jj_scan_token(PARTITION)) return true;
35098 if (jj_3R_123()) return true;
35099 if (jj_scan_token(BY)) return true;
35100 Token xsp;
35101 xsp = jj_scanpos;
35102 if (jj_scan_token(48)) {
35103 jj_scanpos = xsp;
35104 if (jj_3R_615()) return true;
35105 }
35106 if (jj_scan_token(7)) return true;
35107 xsp = jj_scanpos;
35108 if (jj_3R_616()) jj_scanpos = xsp;
35109 return false;
35110 }
35111
35112 private boolean jj_3R_118() {
35113 if (jj_3R_123()) return true;
35114 if (jj_scan_token(EXCEPTION)) return true;
35115 if (jj_scan_token(4)) return true;
35116 return false;
35117 }
35118
35119 private boolean jj_3R_512() {
35120 if (jj_3R_123()) return true;
35121 return false;
35122 }
35123
35124 private boolean jj_3R_463() {
35125 if (jj_3R_127()) return true;
35126 if (jj_scan_token(5)) return true;
35127 if (jj_3R_485()) return true;
35128 return false;
35129 }
35130
35131 private boolean jj_3R_462() {
35132 if (jj_scan_token(INTERFACE)) return true;
35133 if (jj_scan_token(5)) return true;
35134 if (jj_scan_token(IDENTIFIER)) return true;
35135 if (jj_scan_token(6)) return true;
35136 if (jj_3R_123()) return true;
35137 Token xsp;
35138 xsp = jj_scanpos;
35139 if (jj_3R_484()) jj_scanpos = xsp;
35140 if (jj_scan_token(7)) return true;
35141 return false;
35142 }
35143
35144 private boolean jj_3R_461() {
35145 if (jj_scan_token(EXCEPTION_INIT)) return true;
35146 if (jj_scan_token(5)) return true;
35147 if (jj_scan_token(IDENTIFIER)) return true;
35148 if (jj_scan_token(6)) return true;
35149 Token xsp;
35150 xsp = jj_scanpos;
35151 if (jj_3R_483()) jj_scanpos = xsp;
35152 if (jj_3R_126()) return true;
35153 if (jj_scan_token(7)) return true;
35154 return false;
35155 }
35156
35157 private boolean jj_3R_482() {
35158 if (jj_scan_token(6)) return true;
35159 Token xsp;
35160 xsp = jj_scanpos;
35161 if (jj_3R_512()) {
35162 jj_scanpos = xsp;
35163 if (jj_3R_513()) return true;
35164 }
35165 return false;
35166 }
35167
35168 private boolean jj_3R_460() {
35169 if (jj_scan_token(RESTRICT_REFERENCES)) return true;
35170 if (jj_scan_token(5)) return true;
35171 if (jj_3R_123()) return true;
35172 Token xsp;
35173 if (jj_3R_482()) return true;
35174 while (true) {
35175 xsp = jj_scanpos;
35176 if (jj_3R_482()) { jj_scanpos = xsp; break; }
35177 }
35178 if (jj_scan_token(7)) return true;
35179 return false;
35180 }
35181
35182 private boolean jj_3R_459() {
35183 if (jj_scan_token(TIMESTAMP)) return true;
35184 if (jj_scan_token(5)) return true;
35185 if (jj_3R_181()) return true;
35186 if (jj_scan_token(7)) return true;
35187 return false;
35188 }
35189
35190 private boolean jj_3_38() {
35191 if (jj_scan_token(TO)) return true;
35192 if (jj_scan_token(SECOND)) return true;
35193 Token xsp;
35194 xsp = jj_scanpos;
35195 if (jj_3_34()) jj_scanpos = xsp;
35196 return false;
35197 }
35198
35199 private boolean jj_3_37() {
35200 if (jj_scan_token(TO)) return true;
35201 if (jj_scan_token(MONTH)) return true;
35202 return false;
35203 }
35204
35205 private boolean jj_3_36() {
35206 if (jj_scan_token(WITH)) return true;
35207 if (jj_scan_token(TIME)) return true;
35208 if (jj_scan_token(ZONE)) return true;
35209 return false;
35210 }
35211
35212 private boolean jj_3_35() {
35213 if (jj_scan_token(WITH)) return true;
35214 if (jj_scan_token(LOCAL)) return true;
35215 if (jj_scan_token(TIME)) return true;
35216 if (jj_scan_token(ZONE)) return true;
35217 return false;
35218 }
35219
35220 private boolean jj_3R_205() {
35221 Token xsp;
35222 xsp = jj_scanpos;
35223 if (jj_3R_289()) {
35224 jj_scanpos = xsp;
35225 if (jj_3_35()) {
35226 jj_scanpos = xsp;
35227 if (jj_3_36()) {
35228 jj_scanpos = xsp;
35229 if (jj_3_37()) {
35230 jj_scanpos = xsp;
35231 if (jj_3_38()) return true;
35232 }
35233 }
35234 }
35235 }
35236 return false;
35237 }
35238
35239 private boolean jj_3R_289() {
35240 if (jj_scan_token(CHARACTER)) return true;
35241 if (jj_scan_token(SET)) return true;
35242 if (jj_3R_293()) return true;
35243 return false;
35244 }
35245
35246 private boolean jj_3R_418() {
35247 if (jj_scan_token(PRAGMA)) return true;
35248 Token xsp;
35249 xsp = jj_scanpos;
35250 if (jj_scan_token(38)) {
35251 jj_scanpos = xsp;
35252 if (jj_scan_token(41)) {
35253 jj_scanpos = xsp;
35254 if (jj_3R_459()) {
35255 jj_scanpos = xsp;
35256 if (jj_3R_460()) {
35257 jj_scanpos = xsp;
35258 if (jj_3R_461()) {
35259 jj_scanpos = xsp;
35260 if (jj_3R_462()) {
35261 jj_scanpos = xsp;
35262 if (jj_3R_463()) return true;
35263 }
35264 }
35265 }
35266 }
35267 }
35268 }
35269 if (jj_scan_token(4)) return true;
35270 return false;
35271 }
35272
35273 private boolean jj_3R_436() {
35274 if (jj_scan_token(BYTE)) return true;
35275 return false;
35276 }
35277
35278 private boolean jj_3R_435() {
35279 if (jj_scan_token(CHAR)) return true;
35280 return false;
35281 }
35282
35283 private boolean jj_3R_434() {
35284 if (jj_scan_token(6)) return true;
35285 if (jj_3R_478()) return true;
35286 return false;
35287 }
35288
35289 private boolean jj_3_33() {
35290 if (jj_scan_token(5)) return true;
35291 if (jj_3R_126()) return true;
35292 Token xsp;
35293 xsp = jj_scanpos;
35294 if (jj_3R_434()) jj_scanpos = xsp;
35295 xsp = jj_scanpos;
35296 if (jj_3R_435()) jj_scanpos = xsp;
35297 xsp = jj_scanpos;
35298 if (jj_3R_436()) jj_scanpos = xsp;
35299 if (jj_scan_token(7)) return true;
35300 return false;
35301 }
35302
35303 private boolean jj_3R_120() {
35304 if (jj_3R_196()) return true;
35305 if (jj_scan_token(4)) return true;
35306 return false;
35307 }
35308
35309 private boolean jj_3R_204() {
35310 if (jj_scan_token(SELF)) return true;
35311 if (jj_scan_token(AS)) return true;
35312 if (jj_scan_token(RESULT)) return true;
35313 return false;
35314 }
35315
35316 private boolean jj_3R_201() {
35317 if (jj_scan_token(DOUBLE)) return true;
35318 if (jj_scan_token(PRECISION)) return true;
35319 return false;
35320 }
35321
35322 private boolean jj_3_32() {
35323 if (jj_scan_token(INTERVAL)) return true;
35324 if (jj_scan_token(DAY)) return true;
35325 return false;
35326 }
35327
35328 private boolean jj_3_31() {
35329 if (jj_scan_token(INTERVAL)) return true;
35330 if (jj_scan_token(YEAR)) return true;
35331 return false;
35332 }
35333
35334 private boolean jj_3R_563() {
35335 if (jj_scan_token(USING)) return true;
35336 Token xsp;
35337 xsp = jj_scanpos;
35338 if (jj_scan_token(398)) {
35339 jj_scanpos = xsp;
35340 if (jj_scan_token(399)) return true;
35341 }
35342 return false;
35343 }
35344
35345 private boolean jj_3R_203() {
35346 if (jj_scan_token(REF)) return true;
35347 if (jj_scan_token(CURSOR)) return true;
35348 return false;
35349 }
35350
35351 private boolean jj_3_57() {
35352 if (jj_3R_141()) return true;
35353 Token xsp;
35354 xsp = jj_scanpos;
35355 if (jj_scan_token(23)) {
35356 jj_scanpos = xsp;
35357 if (jj_scan_token(50)) return true;
35358 }
35359 return false;
35360 }
35361
35362 private boolean jj_3R_431() {
35363 Token xsp;
35364 xsp = jj_scanpos;
35365 if (jj_3_57()) jj_scanpos = xsp;
35366 if (jj_3R_232()) return true;
35367 xsp = jj_scanpos;
35368 if (jj_3R_563()) jj_scanpos = xsp;
35369 return false;
35370 }
35371
35372 private boolean jj_3_30() {
35373 if (jj_scan_token(LONG)) return true;
35374 if (jj_scan_token(RAW)) return true;
35375 return false;
35376 }
35377
35378 private boolean jj_3R_530() {
35379 if (jj_scan_token(6)) return true;
35380 if (jj_3R_431()) return true;
35381 return false;
35382 }
35383
35384 private boolean jj_3R_202() {
35385 Token xsp;
35386 xsp = jj_scanpos;
35387 if (jj_scan_token(66)) {
35388 jj_scanpos = xsp;
35389 if (jj_scan_token(317)) {
35390 jj_scanpos = xsp;
35391 if (jj_3_30()) {
35392 jj_scanpos = xsp;
35393 if (jj_scan_token(158)) {
35394 jj_scanpos = xsp;
35395 if (jj_scan_token(303)) {
35396 jj_scanpos = xsp;
35397 if (jj_scan_token(304)) {
35398 jj_scanpos = xsp;
35399 if (jj_scan_token(224)) {
35400 jj_scanpos = xsp;
35401 if (jj_scan_token(241)) {
35402 jj_scanpos = xsp;
35403 if (jj_scan_token(305)) {
35404 jj_scanpos = xsp;
35405 if (jj_scan_token(306)) {
35406 jj_scanpos = xsp;
35407 if (jj_scan_token(295)) {
35408 jj_scanpos = xsp;
35409 if (jj_scan_token(296)) {
35410 jj_scanpos = xsp;
35411 if (jj_scan_token(311)) {
35412 jj_scanpos = xsp;
35413 if (jj_scan_token(312)) return true;
35414 }
35415 }
35416 }
35417 }
35418 }
35419 }
35420 }
35421 }
35422 }
35423 }
35424 }
35425 }
35426 }
35427 return false;
35428 }
35429
35430 private boolean jj_3R_390() {
35431 if (jj_3R_431()) return true;
35432 Token xsp;
35433 while (true) {
35434 xsp = jj_scanpos;
35435 if (jj_3R_530()) { jj_scanpos = xsp; break; }
35436 }
35437 return false;
35438 }
35439
35440 private boolean jj_3R_340() {
35441 if (jj_3R_390()) return true;
35442 return false;
35443 }
35444
35445 private boolean jj_3R_140() {
35446 if (jj_scan_token(11)) return true;
35447 return false;
35448 }
35449
35450 private boolean jj_3R_297() {
35451 if (jj_scan_token(5)) return true;
35452 Token xsp;
35453 xsp = jj_scanpos;
35454 if (jj_3R_340()) jj_scanpos = xsp;
35455 if (jj_scan_token(7)) return true;
35456 return false;
35457 }
35458
35459 private boolean jj_3R_125() {
35460 Token xsp;
35461 xsp = jj_scanpos;
35462 if (jj_scan_token(186)) {
35463 jj_scanpos = xsp;
35464 if (jj_scan_token(187)) {
35465 jj_scanpos = xsp;
35466 if (jj_scan_token(67)) {
35467 jj_scanpos = xsp;
35468 if (jj_scan_token(188)) {
35469 jj_scanpos = xsp;
35470 if (jj_scan_token(189)) {
35471 jj_scanpos = xsp;
35472 if (jj_scan_token(190)) {
35473 jj_scanpos = xsp;
35474 if (jj_scan_token(58)) {
35475 jj_scanpos = xsp;
35476 if (jj_scan_token(298)) {
35477 jj_scanpos = xsp;
35478 if (jj_scan_token(90)) {
35479 jj_scanpos = xsp;
35480 if (jj_3R_201()) {
35481 jj_scanpos = xsp;
35482 if (jj_scan_token(119)) {
35483 jj_scanpos = xsp;
35484 if (jj_scan_token(300)) {
35485 jj_scanpos = xsp;
35486 if (jj_scan_token(144)) {
35487 jj_scanpos = xsp;
35488 if (jj_scan_token(172)) {
35489 jj_scanpos = xsp;
35490 if (jj_scan_token(173)) {
35491 jj_scanpos = xsp;
35492 if (jj_scan_token(185)) {
35493 jj_scanpos = xsp;
35494 if (jj_scan_token(301)) {
35495 jj_scanpos = xsp;
35496 if (jj_scan_token(212)) {
35497 jj_scanpos = xsp;
35498 if (jj_scan_token(213)) {
35499 jj_scanpos = xsp;
35500 if (jj_scan_token(214)) {
35501 jj_scanpos = xsp;
35502 if (jj_scan_token(225)) {
35503 jj_scanpos = xsp;
35504 if (jj_scan_token(302)) {
35505 jj_scanpos = xsp;
35506 if (jj_scan_token(253)) {
35507 jj_scanpos = xsp;
35508 if (jj_3R_202()) {
35509 jj_scanpos = xsp;
35510 if (jj_scan_token(60)) {
35511 jj_scanpos = xsp;
35512 if (jj_scan_token(309)) {
35513 jj_scanpos = xsp;
35514 if (jj_scan_token(310)) {
35515 jj_scanpos = xsp;
35516 if (jj_scan_token(267)) {
35517 jj_scanpos = xsp;
35518 if (jj_3R_203()) {
35519 jj_scanpos = xsp;
35520 if (jj_scan_token(87)) {
35521 jj_scanpos = xsp;
35522 if (jj_3_31()) {
35523 jj_scanpos = xsp;
35524 if (jj_3_32()) {
35525 jj_scanpos = xsp;
35526 if (jj_scan_token(271)) {
35527 jj_scanpos = xsp;
35528 if (jj_scan_token(272)) {
35529 jj_scanpos = xsp;
35530 if (jj_3R_204()) return true;
35531 }
35532 }
35533 }
35534 }
35535 }
35536 }
35537 }
35538 }
35539 }
35540 }
35541 }
35542 }
35543 }
35544 }
35545 }
35546 }
35547 }
35548 }
35549 }
35550 }
35551 }
35552 }
35553 }
35554 }
35555 }
35556 }
35557 }
35558 }
35559 }
35560 }
35561 }
35562 }
35563 }
35564 }
35565 xsp = jj_scanpos;
35566 if (jj_3_33()) jj_scanpos = xsp;
35567 xsp = jj_scanpos;
35568 if (jj_3R_205()) jj_scanpos = xsp;
35569 return false;
35570 }
35571
35572 private boolean jj_3R_350() {
35573 if (jj_scan_token(3)) return true;
35574 if (jj_3R_119()) return true;
35575 return false;
35576 }
35577
35578 private boolean jj_3R_238() {
35579 if (jj_scan_token(VARYING)) return true;
35580 if (jj_scan_token(ARRAY)) return true;
35581 return false;
35582 }
35583
35584 private boolean jj_3R_127() {
35585 if (jj_3R_141()) return true;
35586 Token xsp;
35587 while (true) {
35588 xsp = jj_scanpos;
35589 if (jj_3R_350()) { jj_scanpos = xsp; break; }
35590 }
35591 return false;
35592 }
35593
35594 private boolean jj_3R_281() {
35595 Token xsp;
35596 xsp = jj_scanpos;
35597 if (jj_scan_token(116)) {
35598 jj_scanpos = xsp;
35599 if (jj_scan_token(280)) {
35600 jj_scanpos = xsp;
35601 if (jj_scan_token(293)) {
35602 jj_scanpos = xsp;
35603 if (jj_scan_token(374)) {
35604 jj_scanpos = xsp;
35605 if (jj_scan_token(43)) {
35606 jj_scanpos = xsp;
35607 if (jj_scan_token(318)) {
35608 jj_scanpos = xsp;
35609 if (jj_scan_token(44)) {
35610 jj_scanpos = xsp;
35611 if (jj_scan_token(341)) {
35612 jj_scanpos = xsp;
35613 if (jj_scan_token(342)) {
35614 jj_scanpos = xsp;
35615 if (jj_scan_token(52)) {
35616 jj_scanpos = xsp;
35617 if (jj_scan_token(386)) {
35618 jj_scanpos = xsp;
35619 if (jj_scan_token(53)) {
35620 jj_scanpos = xsp;
35621 if (jj_scan_token(343)) {
35622 jj_scanpos = xsp;
35623 if (jj_scan_token(405)) {
35624 jj_scanpos = xsp;
35625 if (jj_scan_token(54)) {
35626 jj_scanpos = xsp;
35627 if (jj_scan_token(319)) {
35628 jj_scanpos = xsp;
35629 if (jj_scan_token(309)) {
35630 jj_scanpos = xsp;
35631 if (jj_scan_token(310)) {
35632 jj_scanpos = xsp;
35633 if (jj_scan_token(392)) {
35634 jj_scanpos = xsp;
35635 if (jj_scan_token(61)) {
35636 jj_scanpos = xsp;
35637 if (jj_scan_token(63)) {
35638 jj_scanpos = xsp;
35639 if (jj_scan_token(346)) {
35640 jj_scanpos = xsp;
35641 if (jj_scan_token(64)) {
35642 jj_scanpos = xsp;
35643 if (jj_scan_token(387)) {
35644 jj_scanpos = xsp;
35645 if (jj_scan_token(398)) {
35646 jj_scanpos = xsp;
35647 if (jj_scan_token(317)) {
35648 jj_scanpos = xsp;
35649 if (jj_scan_token(373)) {
35650 jj_scanpos = xsp;
35651 if (jj_scan_token(372)) {
35652 jj_scanpos = xsp;
35653 if (jj_scan_token(311)) {
35654 jj_scanpos = xsp;
35655 if (jj_scan_token(69)) {
35656 jj_scanpos = xsp;
35657 if (jj_scan_token(71)) {
35658 jj_scanpos = xsp;
35659 if (jj_scan_token(72)) {
35660 jj_scanpos = xsp;
35661 if (jj_scan_token(73)) {
35662 jj_scanpos = xsp;
35663 if (jj_scan_token(74)) {
35664 jj_scanpos = xsp;
35665 if (jj_scan_token(75)) {
35666 jj_scanpos = xsp;
35667 if (jj_scan_token(344)) {
35668 jj_scanpos = xsp;
35669 if (jj_scan_token(79)) {
35670 jj_scanpos = xsp;
35671 if (jj_scan_token(367)) {
35672 jj_scanpos = xsp;
35673 if (jj_scan_token(80)) {
35674 jj_scanpos = xsp;
35675 if (jj_scan_token(81)) {
35676 jj_scanpos = xsp;
35677 if (jj_scan_token(376)) {
35678 jj_scanpos = xsp;
35679 if (jj_scan_token(83)) {
35680 jj_scanpos = xsp;
35681 if (jj_scan_token(37)) {
35682 jj_scanpos = xsp;
35683 if (jj_scan_token(85)) {
35684 jj_scanpos = xsp;
35685 if (jj_scan_token(86)) {
35686 jj_scanpos = xsp;
35687 if (jj_scan_token(345)) {
35688 jj_scanpos = xsp;
35689 if (jj_scan_token(88)) {
35690 jj_scanpos = xsp;
35691 if (jj_scan_token(403)) {
35692 jj_scanpos = xsp;
35693 if (jj_scan_token(347)) {
35694 jj_scanpos = xsp;
35695 if (jj_scan_token(298)) {
35696 jj_scanpos = xsp;
35697 if (jj_scan_token(377)) {
35698 jj_scanpos = xsp;
35699 if (jj_scan_token(36)) {
35700 jj_scanpos = xsp;
35701 if (jj_scan_token(408)) {
35702 jj_scanpos = xsp;
35703 if (jj_scan_token(95)) {
35704 jj_scanpos = xsp;
35705 if (jj_scan_token(348)) {
35706 jj_scanpos = xsp;
35707 if (jj_scan_token(378)) {
35708 jj_scanpos = xsp;
35709 if (jj_scan_token(297)) {
35710 jj_scanpos = xsp;
35711 if (jj_scan_token(349)) {
35712 jj_scanpos = xsp;
35713 if (jj_scan_token(100)) {
35714 jj_scanpos = xsp;
35715 if (jj_scan_token(393)) {
35716 jj_scanpos = xsp;
35717 if (jj_scan_token(103)) {
35718 jj_scanpos = xsp;
35719 if (jj_scan_token(105)) {
35720 jj_scanpos = xsp;
35721 if (jj_scan_token(106)) {
35722 jj_scanpos = xsp;
35723 if (jj_scan_token(108)) {
35724 jj_scanpos = xsp;
35725 if (jj_scan_token(112)) {
35726 jj_scanpos = xsp;
35727 if (jj_scan_token(114)) {
35728 jj_scanpos = xsp;
35729 if (jj_scan_token(113)) {
35730 jj_scanpos = xsp;
35731 if (jj_scan_token(115)) {
35732 jj_scanpos = xsp;
35733 if (jj_scan_token(118)) {
35734 jj_scanpos = xsp;
35735 if (jj_scan_token(350)) {
35736 jj_scanpos = xsp;
35737 if (jj_scan_token(122)) {
35738 jj_scanpos = xsp;
35739 if (jj_scan_token(124)) {
35740 jj_scanpos = xsp;
35741 if (jj_scan_token(125)) {
35742 jj_scanpos = xsp;
35743 if (jj_scan_token(129)) {
35744 jj_scanpos = xsp;
35745 if (jj_scan_token(131)) {
35746 jj_scanpos = xsp;
35747 if (jj_scan_token(379)) {
35748 jj_scanpos = xsp;
35749 if (jj_scan_token(132)) {
35750 jj_scanpos = xsp;
35751 if (jj_scan_token(135)) {
35752 jj_scanpos = xsp;
35753 if (jj_scan_token(140)) {
35754 jj_scanpos = xsp;
35755 if (jj_scan_token(141)) {
35756 jj_scanpos = xsp;
35757 if (jj_scan_token(138)) {
35758 jj_scanpos = xsp;
35759 if (jj_scan_token(143)) {
35760 jj_scanpos = xsp;
35761 if (jj_scan_token(147)) {
35762 jj_scanpos = xsp;
35763 if (jj_scan_token(149)) {
35764 jj_scanpos = xsp;
35765 if (jj_scan_token(151)) {
35766 jj_scanpos = xsp;
35767 if (jj_scan_token(152)) {
35768 jj_scanpos = xsp;
35769 if (jj_scan_token(42)) {
35770 jj_scanpos = xsp;
35771 if (jj_scan_token(396)) {
35772 jj_scanpos = xsp;
35773 if (jj_scan_token(390)) {
35774 jj_scanpos = xsp;
35775 if (jj_scan_token(369)) {
35776 jj_scanpos = xsp;
35777 if (jj_scan_token(153)) {
35778 jj_scanpos = xsp;
35779 if (jj_scan_token(364)) {
35780 jj_scanpos = xsp;
35781 if (jj_scan_token(155)) {
35782 jj_scanpos = xsp;
35783 if (jj_scan_token(406)) {
35784 jj_scanpos = xsp;
35785 if (jj_scan_token(314)) {
35786 jj_scanpos = xsp;
35787 if (jj_scan_token(351)) {
35788 jj_scanpos = xsp;
35789 if (jj_scan_token(352)) {
35790 jj_scanpos = xsp;
35791 if (jj_scan_token(160)) {
35792 jj_scanpos = xsp;
35793 if (jj_scan_token(161)) {
35794 jj_scanpos = xsp;
35795 if (jj_scan_token(371)) {
35796 jj_scanpos = xsp;
35797 if (jj_scan_token(162)) {
35798 jj_scanpos = xsp;
35799 if (jj_scan_token(163)) {
35800 jj_scanpos = xsp;
35801 if (jj_scan_token(164)) {
35802 jj_scanpos = xsp;
35803 if (jj_scan_token(166)) {
35804 jj_scanpos = xsp;
35805 if (jj_scan_token(167)) {
35806 jj_scanpos = xsp;
35807 if (jj_scan_token(168)) {
35808 jj_scanpos = xsp;
35809 if (jj_scan_token(171)) {
35810 jj_scanpos = xsp;
35811 if (jj_scan_token(394)) {
35812 jj_scanpos = xsp;
35813 if (jj_scan_token(365)) {
35814 jj_scanpos = xsp;
35815 if (jj_scan_token(172)) {
35816 jj_scanpos = xsp;
35817 if (jj_scan_token(303)) {
35818 jj_scanpos = xsp;
35819 if (jj_scan_token(399)) {
35820 jj_scanpos = xsp;
35821 if (jj_scan_token(312)) {
35822 jj_scanpos = xsp;
35823 if (jj_scan_token(353)) {
35824 jj_scanpos = xsp;
35825 if (jj_scan_token(174)) {
35826 jj_scanpos = xsp;
35827 if (jj_scan_token(177)) {
35828 jj_scanpos = xsp;
35829 if (jj_scan_token(354)) {
35830 jj_scanpos = xsp;
35831 if (jj_scan_token(301)) {
35832 jj_scanpos = xsp;
35833 if (jj_scan_token(304)) {
35834 jj_scanpos = xsp;
35835 if (jj_scan_token(191)) {
35836 jj_scanpos = xsp;
35837 if (jj_scan_token(194)) {
35838 jj_scanpos = xsp;
35839 if (jj_scan_token(323)) {
35840 jj_scanpos = xsp;
35841 if (jj_scan_token(196)) {
35842 jj_scanpos = xsp;
35843 if (jj_scan_token(197)) {
35844 jj_scanpos = xsp;
35845 if (jj_scan_token(202)) {
35846 jj_scanpos = xsp;
35847 if (jj_scan_token(203)) {
35848 jj_scanpos = xsp;
35849 if (jj_scan_token(205)) {
35850 jj_scanpos = xsp;
35851 if (jj_scan_token(206)) {
35852 jj_scanpos = xsp;
35853 if (jj_scan_token(368)) {
35854 jj_scanpos = xsp;
35855 if (jj_scan_token(324)) {
35856 jj_scanpos = xsp;
35857 if (jj_scan_token(208)) {
35858 jj_scanpos = xsp;
35859 if (jj_scan_token(299)) {
35860 jj_scanpos = xsp;
35861 if (jj_scan_token(216)) {
35862 jj_scanpos = xsp;
35863 if (jj_scan_token(380)) {
35864 jj_scanpos = xsp;
35865 if (jj_scan_token(220)) {
35866 jj_scanpos = xsp;
35867 if (jj_scan_token(381)) {
35868 jj_scanpos = xsp;
35869 if (jj_scan_token(223)) {
35870 jj_scanpos = xsp;
35871 if (jj_scan_token(225)) {
35872 jj_scanpos = xsp;
35873 if (jj_scan_token(226)) {
35874 jj_scanpos = xsp;
35875 if (jj_scan_token(227)) {
35876 jj_scanpos = xsp;
35877 if (jj_scan_token(229)) {
35878 jj_scanpos = xsp;
35879 if (jj_scan_token(382)) {
35880 jj_scanpos = xsp;
35881 if (jj_scan_token(232)) {
35882 jj_scanpos = xsp;
35883 if (jj_scan_token(234)) {
35884 jj_scanpos = xsp;
35885 if (jj_scan_token(235)) {
35886 jj_scanpos = xsp;
35887 if (jj_scan_token(236)) {
35888 jj_scanpos = xsp;
35889 if (jj_scan_token(391)) {
35890 jj_scanpos = xsp;
35891 if (jj_scan_token(238)) {
35892 jj_scanpos = xsp;
35893 if (jj_scan_token(239)) {
35894 jj_scanpos = xsp;
35895 if (jj_scan_token(241)) {
35896 jj_scanpos = xsp;
35897 if (jj_scan_token(242)) {
35898 jj_scanpos = xsp;
35899 if (jj_scan_token(240)) {
35900 jj_scanpos = xsp;
35901 if (jj_scan_token(244)) {
35902 jj_scanpos = xsp;
35903 if (jj_scan_token(245)) {
35904 jj_scanpos = xsp;
35905 if (jj_scan_token(355)) {
35906 jj_scanpos = xsp;
35907 if (jj_scan_token(246)) {
35908 jj_scanpos = xsp;
35909 if (jj_scan_token(248)) {
35910 jj_scanpos = xsp;
35911 if (jj_scan_token(356)) {
35912 jj_scanpos = xsp;
35913 if (jj_scan_token(404)) {
35914 jj_scanpos = xsp;
35915 if (jj_scan_token(250)) {
35916 jj_scanpos = xsp;
35917 if (jj_scan_token(407)) {
35918 jj_scanpos = xsp;
35919 if (jj_scan_token(357)) {
35920 jj_scanpos = xsp;
35921 if (jj_scan_token(254)) {
35922 jj_scanpos = xsp;
35923 if (jj_scan_token(358)) {
35924 jj_scanpos = xsp;
35925 if (jj_scan_token(359)) {
35926 jj_scanpos = xsp;
35927 if (jj_scan_token(259)) {
35928 jj_scanpos = xsp;
35929 if (jj_scan_token(360)) {
35930 jj_scanpos = xsp;
35931 if (jj_scan_token(366)) {
35932 jj_scanpos = xsp;
35933 if (jj_scan_token(395)) {
35934 jj_scanpos = xsp;
35935 if (jj_scan_token(262)) {
35936 jj_scanpos = xsp;
35937 if (jj_scan_token(261)) {
35938 jj_scanpos = xsp;
35939 if (jj_scan_token(263)) {
35940 jj_scanpos = xsp;
35941 if (jj_scan_token(361)) {
35942 jj_scanpos = xsp;
35943 if (jj_scan_token(370)) {
35944 jj_scanpos = xsp;
35945 if (jj_scan_token(269)) {
35946 jj_scanpos = xsp;
35947 if (jj_scan_token(271)) {
35948 jj_scanpos = xsp;
35949 if (jj_scan_token(272)) {
35950 jj_scanpos = xsp;
35951 if (jj_scan_token(274)) {
35952 jj_scanpos = xsp;
35953 if (jj_scan_token(276)) {
35954 jj_scanpos = xsp;
35955 if (jj_scan_token(275)) {
35956 jj_scanpos = xsp;
35957 if (jj_scan_token(273)) {
35958 jj_scanpos = xsp;
35959 if (jj_scan_token(397)) {
35960 jj_scanpos = xsp;
35961 if (jj_scan_token(278)) {
35962 jj_scanpos = xsp;
35963 if (jj_scan_token(388)) {
35964 jj_scanpos = xsp;
35965 if (jj_scan_token(389)) {
35966 jj_scanpos = xsp;
35967 if (jj_scan_token(362)) {
35968 jj_scanpos = xsp;
35969 if (jj_scan_token(383)) {
35970 jj_scanpos = xsp;
35971 if (jj_scan_token(283)) {
35972 jj_scanpos = xsp;
35973 if (jj_scan_token(306)) {
35974 jj_scanpos = xsp;
35975 if (jj_scan_token(409)) {
35976 jj_scanpos = xsp;
35977 if (jj_scan_token(285)) {
35978 jj_scanpos = xsp;
35979 if (jj_scan_token(307)) {
35980 jj_scanpos = xsp;
35981 if (jj_scan_token(384)) {
35982 jj_scanpos = xsp;
35983 if (jj_scan_token(308)) {
35984 jj_scanpos = xsp;
35985 if (jj_scan_token(385)) {
35986 jj_scanpos = xsp;
35987 if (jj_scan_token(313)) {
35988 jj_scanpos = xsp;
35989 if (jj_scan_token(290)) {
35990 jj_scanpos = xsp;
35991 if (jj_scan_token(316)) {
35992 jj_scanpos = xsp;
35993 if (jj_scan_token(291)) {
35994 jj_scanpos = xsp;
35995 if (jj_scan_token(363)) {
35996 jj_scanpos = xsp;
35997 if (jj_scan_token(267)) {
35998 jj_scanpos = xsp;
35999 if (jj_scan_token(99)) {
36000 jj_scanpos = xsp;
36001 if (jj_scan_token(180)) {
36002 jj_scanpos = xsp;
36003 if (jj_scan_token(375)) {
36004 jj_scanpos = xsp;
36005 if (jj_scan_token(184)) {
36006 jj_scanpos = xsp;
36007 if (jj_scan_token(230)) {
36008 jj_scanpos = xsp;
36009 if (jj_scan_token(228)) return true;
36010 }
36011 }
36012 }
36013 }
36014 }
36015 }
36016 }
36017 }
36018 }
36019 }
36020 }
36021 }
36022 }
36023 }
36024 }
36025 }
36026 }
36027 }
36028 }
36029 }
36030 }
36031 }
36032 }
36033 }
36034 }
36035 }
36036 }
36037 }
36038 }
36039 }
36040 }
36041 }
36042 }
36043 }
36044 }
36045 }
36046 }
36047 }
36048 }
36049 }
36050 }
36051 }
36052 }
36053 }
36054 }
36055 }
36056 }
36057 }
36058 }
36059 }
36060 }
36061 }
36062 }
36063 }
36064 }
36065 }
36066 }
36067 }
36068 }
36069 }
36070 }
36071 }
36072 }
36073 }
36074 }
36075 }
36076 }
36077 }
36078 }
36079 }
36080 }
36081 }
36082 }
36083 }
36084 }
36085 }
36086 }
36087 }
36088 }
36089 }
36090 }
36091 }
36092 }
36093 }
36094 }
36095 }
36096 }
36097 }
36098 }
36099 }
36100 }
36101 }
36102 }
36103 }
36104 }
36105 }
36106 }
36107 }
36108 }
36109 }
36110 }
36111 }
36112 }
36113 }
36114 }
36115 }
36116 }
36117 }
36118 }
36119 }
36120 }
36121 }
36122 }
36123 }
36124 }
36125 }
36126 }
36127 }
36128 }
36129 }
36130 }
36131 }
36132 }
36133 }
36134 }
36135 }
36136 }
36137 }
36138 }
36139 }
36140 }
36141 }
36142 }
36143 }
36144 }
36145 }
36146 }
36147 }
36148 }
36149 }
36150 }
36151 }
36152 }
36153 }
36154 }
36155 }
36156 }
36157 }
36158 }
36159 }
36160 }
36161 }
36162 }
36163 }
36164 }
36165 }
36166 }
36167 }
36168 }
36169 }
36170 }
36171 }
36172 }
36173 }
36174 }
36175 }
36176 }
36177 }
36178 }
36179 }
36180 }
36181 }
36182 }
36183 }
36184 }
36185 }
36186 }
36187 }
36188 }
36189 }
36190 }
36191 }
36192 }
36193 }
36194 }
36195 }
36196 }
36197 }
36198 }
36199 }
36200 }
36201 }
36202 }
36203 }
36204 }
36205 }
36206 }
36207 }
36208 }
36209 }
36210 }
36211 }
36212 }
36213 }
36214 }
36215 }
36216 return false;
36217 }
36218
36219 private boolean jj_3_29() {
36220 if (jj_scan_token(5)) return true;
36221 if (jj_3R_126()) return true;
36222 return false;
36223 }
36224
36225 private boolean jj_3R_139() {
36226 if (jj_scan_token(3)) return true;
36227 return false;
36228 }
36229
36230 private boolean jj_3_56() {
36231 Token xsp;
36232 xsp = jj_scanpos;
36233 if (jj_3R_139()) {
36234 jj_scanpos = xsp;
36235 if (jj_3R_140()) return true;
36236 }
36237 if (jj_3R_119()) return true;
36238 return false;
36239 }
36240
36241 private boolean jj_3R_144() {
36242 Token xsp;
36243 xsp = jj_scanpos;
36244 if (jj_scan_token(268)) {
36245 jj_scanpos = xsp;
36246 if (jj_scan_token(307)) {
36247 jj_scanpos = xsp;
36248 if (jj_3R_238()) return true;
36249 }
36250 }
36251 xsp = jj_scanpos;
36252 if (jj_3_29()) jj_scanpos = xsp;
36253 return false;
36254 }
36255
36256 private boolean jj_3R_293() {
36257 if (jj_3R_141()) return true;
36258 Token xsp;
36259 while (true) {
36260 xsp = jj_scanpos;
36261 if (jj_3_56()) { jj_scanpos = xsp; break; }
36262 }
36263 return false;
36264 }
36265
36266 private boolean jj_3R_396() {
36267 if (jj_scan_token(CC_ELSE)) return true;
36268 if (jj_3R_234()) return true;
36269 return false;
36270 }
36271
36272 private boolean jj_3R_189() {
36273 if (jj_scan_token(21)) return true;
36274 if (jj_3R_141()) return true;
36275 if (jj_scan_token(22)) return true;
36276 return false;
36277 }
36278
36279 private boolean jj_3R_395() {
36280 if (jj_scan_token(CC_ELSIF)) return true;
36281 if (jj_3R_342()) return true;
36282 if (jj_scan_token(CC_THEN)) return true;
36283 if (jj_3R_234()) return true;
36284 return false;
36285 }
36286
36287 private boolean jj_3R_344() {
36288 if (jj_scan_token(CC_IF)) return true;
36289 if (jj_3R_342()) return true;
36290 if (jj_scan_token(CC_THEN)) return true;
36291 if (jj_3R_234()) return true;
36292 Token xsp;
36293 while (true) {
36294 xsp = jj_scanpos;
36295 if (jj_3R_395()) { jj_scanpos = xsp; break; }
36296 }
36297 while (true) {
36298 xsp = jj_scanpos;
36299 if (jj_3R_396()) { jj_scanpos = xsp; break; }
36300 }
36301 if (jj_scan_token(CC_END)) return true;
36302 return false;
36303 }
36304
36305 private boolean jj_3R_346() {
36306 if (jj_scan_token(11)) return true;
36307 Token xsp;
36308 xsp = jj_scanpos;
36309 if (jj_scan_token(281)) {
36310 jj_scanpos = xsp;
36311 if (jj_scan_token(243)) return true;
36312 }
36313 return false;
36314 }
36315
36316 private boolean jj_3R_345() {
36317 if (jj_scan_token(2)) return true;
36318 if (jj_3R_127()) return true;
36319 return false;
36320 }
36321
36322 private boolean jj_3R_126() {
36323 if (jj_scan_token(UNSIGNED_NUMERIC_LITERAL)) return true;
36324 return false;
36325 }
36326
36327 private boolean jj_3_27() {
36328 if (jj_scan_token(REF)) return true;
36329 return false;
36330 }
36331
36332 private boolean jj_3R_303() {
36333 Token xsp;
36334 xsp = jj_scanpos;
36335 if (jj_3_27()) jj_scanpos = xsp;
36336 if (jj_3R_127()) return true;
36337 xsp = jj_scanpos;
36338 if (jj_3R_345()) jj_scanpos = xsp;
36339 xsp = jj_scanpos;
36340 if (jj_3R_346()) jj_scanpos = xsp;
36341 return false;
36342 }
36343
36344 private boolean jj_3_28() {
36345 if (jj_3R_125()) return true;
36346 return false;
36347 }
36348
36349 private boolean jj_3R_302() {
36350 if (jj_3R_344()) return true;
36351 return false;
36352 }
36353
36354 private boolean jj_3R_234() {
36355 Token xsp;
36356 xsp = jj_scanpos;
36357 if (jj_3R_302()) {
36358 jj_scanpos = xsp;
36359 if (jj_3_28()) {
36360 jj_scanpos = xsp;
36361 if (jj_3R_303()) return true;
36362 }
36363 }
36364 return false;
36365 }
36366
36367 private boolean jj_3R_225() {
36368 if (jj_scan_token(A)) return true;
36369 if (jj_scan_token(SET)) return true;
36370 return false;
36371 }
36372
36373 private boolean jj_3R_135() {
36374 Token xsp;
36375 xsp = jj_scanpos;
36376 if (jj_3R_225()) {
36377 jj_scanpos = xsp;
36378 if (jj_scan_token(393)) return true;
36379 }
36380 return false;
36381 }
36382
36383 private boolean jj_3R_333() {
36384 if (jj_scan_token(_DEFAULT)) return true;
36385 return false;
36386 }
36387
36388 private boolean jj_3R_388() {
36389 if (jj_scan_token(NULL)) return true;
36390 return false;
36391 }
36392
36393 private boolean jj_3R_334() {
36394 if (jj_3R_232()) return true;
36395 return false;
36396 }
36397
36398 private boolean jj_3R_282() {
36399 if (jj_3R_123()) return true;
36400 return false;
36401 }
36402
36403 private boolean jj_3R_387() {
36404 Token xsp;
36405 xsp = jj_scanpos;
36406 if (jj_scan_token(280)) {
36407 jj_scanpos = xsp;
36408 if (jj_scan_token(116)) return true;
36409 }
36410 return false;
36411 }
36412
36413 private boolean jj_3R_332() {
36414 if (jj_scan_token(9)) return true;
36415 if (jj_scan_token(10)) return true;
36416 return false;
36417 }
36418
36419 private boolean jj_3R_284() {
36420 Token xsp;
36421 xsp = jj_scanpos;
36422 if (jj_3R_332()) {
36423 jj_scanpos = xsp;
36424 if (jj_3R_333()) return true;
36425 }
36426 if (jj_3R_334()) return true;
36427 return false;
36428 }
36429
36430 private boolean jj_3R_331() {
36431 if (jj_scan_token(NOT)) return true;
36432 return false;
36433 }
36434
36435 private boolean jj_3R_283() {
36436 Token xsp;
36437 xsp = jj_scanpos;
36438 if (jj_3R_331()) jj_scanpos = xsp;
36439 if (jj_scan_token(NULL)) return true;
36440 return false;
36441 }
36442
36443 private boolean jj_3_26() {
36444 if (jj_scan_token(CONSTANT)) return true;
36445 return false;
36446 }
36447
36448 private boolean jj_3R_196() {
36449 if (jj_3R_282()) return true;
36450 Token xsp;
36451 xsp = jj_scanpos;
36452 if (jj_3_26()) jj_scanpos = xsp;
36453 if (jj_3R_234()) return true;
36454 xsp = jj_scanpos;
36455 if (jj_3R_283()) jj_scanpos = xsp;
36456 xsp = jj_scanpos;
36457 if (jj_3R_284()) jj_scanpos = xsp;
36458 return false;
36459 }
36460
36461 private boolean jj_3R_509() {
36462 if (jj_scan_token(6)) return true;
36463 if (jj_3R_469()) return true;
36464 return false;
36465 }
36466
36467 private boolean jj_3R_423() {
36468 if (jj_3R_469()) return true;
36469 Token xsp;
36470 while (true) {
36471 xsp = jj_scanpos;
36472 if (jj_3R_509()) { jj_scanpos = xsp; break; }
36473 }
36474 return false;
36475 }
36476
36477 private boolean jj_3R_382() {
36478 if (jj_scan_token(5)) return true;
36479 Token xsp;
36480 xsp = jj_scanpos;
36481 if (jj_3R_423()) jj_scanpos = xsp;
36482 if (jj_scan_token(7)) return true;
36483 return false;
36484 }
36485
36486 private boolean jj_3_23() {
36487 if (jj_scan_token(NOCOPY)) return true;
36488 return false;
36489 }
36490
36491 private boolean jj_3R_324() {
36492 if (jj_3R_382()) return true;
36493 return false;
36494 }
36495
36496 private boolean jj_3R_458() {
36497 if (jj_3R_123()) return true;
36498 return false;
36499 }
36500
36501 private boolean jj_3R_323() {
36502 if (jj_scan_token(RETURN)) return true;
36503 if (jj_3R_234()) return true;
36504 return false;
36505 }
36506
36507 private boolean jj_3R_277() {
36508 if (jj_scan_token(PROCEDURE)) return true;
36509 if (jj_3R_153()) return true;
36510 Token xsp;
36511 xsp = jj_scanpos;
36512 if (jj_3R_324()) jj_scanpos = xsp;
36513 return false;
36514 }
36515
36516 private boolean jj_3R_181() {
36517 if (jj_scan_token(STRING_LITERAL)) return true;
36518 return false;
36519 }
36520
36521 private boolean jj_3R_124() {
36522 if (jj_scan_token(IN)) return true;
36523 if (jj_scan_token(OUT)) return true;
36524 return false;
36525 }
36526
36527 private boolean jj_3R_322() {
36528 if (jj_3R_382()) return true;
36529 return false;
36530 }
36531
36532 private boolean jj_3R_618() {
36533 if (jj_scan_token(3)) return true;
36534 if (jj_3R_123()) return true;
36535 return false;
36536 }
36537
36538 private boolean jj_3R_276() {
36539 if (jj_scan_token(FUNCTION)) return true;
36540 if (jj_3R_153()) return true;
36541 Token xsp;
36542 xsp = jj_scanpos;
36543 if (jj_3R_322()) jj_scanpos = xsp;
36544 xsp = jj_scanpos;
36545 if (jj_3R_323()) jj_scanpos = xsp;
36546 return false;
36547 }
36548
36549 private boolean jj_3R_617() {
36550 if (jj_scan_token(6)) return true;
36551 if (jj_3R_123()) return true;
36552 return false;
36553 }
36554
36555 private boolean jj_3R_457() {
36556 if (jj_3R_348()) return true;
36557 return false;
36558 }
36559
36560 private boolean jj_3R_192() {
36561 Token xsp;
36562 xsp = jj_scanpos;
36563 if (jj_3R_276()) {
36564 jj_scanpos = xsp;
36565 if (jj_3R_277()) return true;
36566 }
36567 return false;
36568 }
36569
36570 private boolean jj_3R_339() {
36571 if (jj_3R_389()) return true;
36572 return false;
36573 }
36574
36575 private boolean jj_3_24() {
36576 Token xsp;
36577 xsp = jj_scanpos;
36578 if (jj_scan_token(204)) {
36579 jj_scanpos = xsp;
36580 if (jj_3R_124()) return true;
36581 }
36582 xsp = jj_scanpos;
36583 if (jj_3_23()) jj_scanpos = xsp;
36584 return false;
36585 }
36586
36587 private boolean jj_3R_338() {
36588 if (jj_3R_388()) return true;
36589 return false;
36590 }
36591
36592 private boolean jj_3R_337() {
36593 if (jj_3R_387()) return true;
36594 return false;
36595 }
36596
36597 private boolean jj_3R_554() {
36598 if (jj_3R_234()) return true;
36599 return false;
36600 }
36601
36602 private boolean jj_3R_596() {
36603 if (jj_scan_token(6)) return true;
36604 if (jj_3R_123()) return true;
36605 Token xsp;
36606 xsp = jj_scanpos;
36607 if (jj_3R_618()) jj_scanpos = xsp;
36608 return false;
36609 }
36610
36611 private boolean jj_3R_481() {
36612 if (jj_scan_token(3)) return true;
36613 if (jj_3R_123()) return true;
36614 return false;
36615 }
36616
36617 private boolean jj_3R_336() {
36618 if (jj_3R_181()) return true;
36619 return false;
36620 }
36621
36622 private boolean jj_3R_465() {
36623 if (jj_3R_145()) return true;
36624 return false;
36625 }
36626
36627 private boolean jj_3R_195() {
36628 if (jj_3R_281()) return true;
36629 return false;
36630 }
36631
36632 private boolean jj_3R_464() {
36633 if (jj_3R_117()) return true;
36634 return false;
36635 }
36636
36637 private boolean jj_3R_335() {
36638 if (jj_3R_126()) return true;
36639 return false;
36640 }
36641
36642 private boolean jj_3R_421() {
36643 Token xsp;
36644 xsp = jj_scanpos;
36645 if (jj_3R_464()) {
36646 jj_scanpos = xsp;
36647 if (jj_3R_465()) return true;
36648 }
36649 return false;
36650 }
36651
36652 private boolean jj_3R_292() {
36653 Token xsp;
36654 xsp = jj_scanpos;
36655 if (jj_3R_335()) {
36656 jj_scanpos = xsp;
36657 if (jj_scan_token(422)) {
36658 jj_scanpos = xsp;
36659 if (jj_3R_336()) {
36660 jj_scanpos = xsp;
36661 if (jj_3R_337()) {
36662 jj_scanpos = xsp;
36663 if (jj_3R_338()) {
36664 jj_scanpos = xsp;
36665 if (jj_3R_339()) return true;
36666 }
36667 }
36668 }
36669 }
36670 }
36671 return false;
36672 }
36673
36674 private boolean jj_3R_592() {
36675 if (jj_scan_token(9)) return true;
36676 if (jj_scan_token(10)) return true;
36677 return false;
36678 }
36679
36680 private boolean jj_3R_456() {
36681 if (jj_3R_172()) return true;
36682 return false;
36683 }
36684
36685 private boolean jj_3R_555() {
36686 Token xsp;
36687 xsp = jj_scanpos;
36688 if (jj_3R_592()) {
36689 jj_scanpos = xsp;
36690 if (jj_scan_token(91)) return true;
36691 }
36692 if (jj_3R_232()) return true;
36693 return false;
36694 }
36695
36696 private boolean jj_3R_473() {
36697 if (jj_3R_232()) return true;
36698 return false;
36699 }
36700
36701 private boolean jj_3R_472() {
36702 if (jj_3R_181()) return true;
36703 return false;
36704 }
36705
36706 private boolean jj_3R_471() {
36707 if (jj_scan_token(SESSIONTIMEZONE)) return true;
36708 return false;
36709 }
36710
36711 private boolean jj_3_25() {
36712 Token xsp;
36713 xsp = jj_scanpos;
36714 if (jj_3_24()) {
36715 jj_scanpos = xsp;
36716 if (jj_scan_token(136)) return true;
36717 }
36718 return false;
36719 }
36720
36721 private boolean jj_3R_470() {
36722 if (jj_scan_token(DBTIMEZONE)) return true;
36723 return false;
36724 }
36725
36726 private boolean jj_3R_595() {
36727 if (jj_scan_token(3)) return true;
36728 if (jj_3R_123()) return true;
36729 return false;
36730 }
36731
36732 private boolean jj_3R_511() {
36733 if (jj_3R_123()) return true;
36734 return false;
36735 }
36736
36737 private boolean jj_3R_384() {
36738 if (jj_scan_token(USING)) return true;
36739 if (jj_3R_123()) return true;
36740 Token xsp;
36741 xsp = jj_scanpos;
36742 if (jj_3R_481()) jj_scanpos = xsp;
36743 return false;
36744 }
36745
36746 private boolean jj_3R_119() {
36747 Token xsp;
36748 xsp = jj_scanpos;
36749 if (jj_scan_token(417)) {
36750 jj_scanpos = xsp;
36751 if (jj_scan_token(425)) {
36752 jj_scanpos = xsp;
36753 if (jj_3R_195()) {
36754 jj_scanpos = xsp;
36755 if (jj_scan_token(35)) {
36756 jj_scanpos = xsp;
36757 if (jj_scan_token(38)) {
36758 jj_scanpos = xsp;
36759 if (jj_scan_token(39)) {
36760 jj_scanpos = xsp;
36761 if (jj_scan_token(40)) {
36762 jj_scanpos = xsp;
36763 if (jj_scan_token(41)) {
36764 jj_scanpos = xsp;
36765 if (jj_scan_token(49)) {
36766 jj_scanpos = xsp;
36767 if (jj_scan_token(55)) {
36768 jj_scanpos = xsp;
36769 if (jj_scan_token(58)) {
36770 jj_scanpos = xsp;
36771 if (jj_scan_token(59)) {
36772 jj_scanpos = xsp;
36773 if (jj_scan_token(60)) {
36774 jj_scanpos = xsp;
36775 if (jj_scan_token(66)) {
36776 jj_scanpos = xsp;
36777 if (jj_scan_token(67)) {
36778 jj_scanpos = xsp;
36779 if (jj_scan_token(78)) {
36780 jj_scanpos = xsp;
36781 if (jj_scan_token(84)) {
36782 jj_scanpos = xsp;
36783 if (jj_scan_token(87)) {
36784 jj_scanpos = xsp;
36785 if (jj_scan_token(90)) {
36786 jj_scanpos = xsp;
36787 if (jj_scan_token(92)) {
36788 jj_scanpos = xsp;
36789 if (jj_scan_token(97)) {
36790 jj_scanpos = xsp;
36791 if (jj_scan_token(102)) {
36792 jj_scanpos = xsp;
36793 if (jj_scan_token(110)) {
36794 jj_scanpos = xsp;
36795 if (jj_scan_token(111)) {
36796 jj_scanpos = xsp;
36797 if (jj_scan_token(119)) {
36798 jj_scanpos = xsp;
36799 if (jj_scan_token(121)) {
36800 jj_scanpos = xsp;
36801 if (jj_scan_token(144)) {
36802 jj_scanpos = xsp;
36803 if (jj_scan_token(145)) {
36804 jj_scanpos = xsp;
36805 if (jj_scan_token(158)) {
36806 jj_scanpos = xsp;
36807 if (jj_scan_token(159)) {
36808 jj_scanpos = xsp;
36809 if (jj_scan_token(169)) {
36810 jj_scanpos = xsp;
36811 if (jj_scan_token(173)) {
36812 jj_scanpos = xsp;
36813 if (jj_scan_token(176)) {
36814 jj_scanpos = xsp;
36815 if (jj_scan_token(179)) {
36816 jj_scanpos = xsp;
36817 if (jj_scan_token(185)) {
36818 jj_scanpos = xsp;
36819 if (jj_scan_token(186)) {
36820 jj_scanpos = xsp;
36821 if (jj_scan_token(187)) {
36822 jj_scanpos = xsp;
36823 if (jj_scan_token(188)) {
36824 jj_scanpos = xsp;
36825 if (jj_scan_token(189)) {
36826 jj_scanpos = xsp;
36827 if (jj_scan_token(190)) {
36828 jj_scanpos = xsp;
36829 if (jj_scan_token(192)) {
36830 jj_scanpos = xsp;
36831 if (jj_scan_token(198)) {
36832 jj_scanpos = xsp;
36833 if (jj_scan_token(204)) {
36834 jj_scanpos = xsp;
36835 if (jj_scan_token(212)) {
36836 jj_scanpos = xsp;
36837 if (jj_scan_token(213)) {
36838 jj_scanpos = xsp;
36839 if (jj_scan_token(214)) {
36840 jj_scanpos = xsp;
36841 if (jj_scan_token(215)) {
36842 jj_scanpos = xsp;
36843 if (jj_scan_token(217)) {
36844 jj_scanpos = xsp;
36845 if (jj_scan_token(219)) {
36846 jj_scanpos = xsp;
36847 if (jj_scan_token(218)) {
36848 jj_scanpos = xsp;
36849 if (jj_scan_token(222)) {
36850 jj_scanpos = xsp;
36851 if (jj_scan_token(224)) {
36852 jj_scanpos = xsp;
36853 if (jj_scan_token(243)) {
36854 jj_scanpos = xsp;
36855 if (jj_scan_token(249)) {
36856 jj_scanpos = xsp;
36857 if (jj_scan_token(253)) {
36858 jj_scanpos = xsp;
36859 if (jj_scan_token(256)) {
36860 jj_scanpos = xsp;
36861 if (jj_scan_token(257)) {
36862 jj_scanpos = xsp;
36863 if (jj_scan_token(260)) {
36864 jj_scanpos = xsp;
36865 if (jj_scan_token(264)) {
36866 jj_scanpos = xsp;
36867 if (jj_scan_token(265)) {
36868 jj_scanpos = xsp;
36869 if (jj_scan_token(266)) {
36870 jj_scanpos = xsp;
36871 if (jj_scan_token(279)) {
36872 jj_scanpos = xsp;
36873 if (jj_scan_token(281)) {
36874 jj_scanpos = xsp;
36875 if (jj_scan_token(282)) {
36876 jj_scanpos = xsp;
36877 if (jj_scan_token(295)) {
36878 jj_scanpos = xsp;
36879 if (jj_scan_token(296)) {
36880 jj_scanpos = xsp;
36881 if (jj_scan_token(300)) {
36882 jj_scanpos = xsp;
36883 if (jj_scan_token(302)) {
36884 jj_scanpos = xsp;
36885 if (jj_scan_token(305)) {
36886 jj_scanpos = xsp;
36887 if (jj_scan_token(289)) return true;
36888 }
36889 }
36890 }
36891 }
36892 }
36893 }
36894 }
36895 }
36896 }
36897 }
36898 }
36899 }
36900 }
36901 }
36902 }
36903 }
36904 }
36905 }
36906 }
36907 }
36908 }
36909 }
36910 }
36911 }
36912 }
36913 }
36914 }
36915 }
36916 }
36917 }
36918 }
36919 }
36920 }
36921 }
36922 }
36923 }
36924 }
36925 }
36926 }
36927 }
36928 }
36929 }
36930 }
36931 }
36932 }
36933 }
36934 }
36935 }
36936 }
36937 }
36938 }
36939 }
36940 }
36941 }
36942 }
36943 }
36944 }
36945 }
36946 }
36947 }
36948 }
36949 }
36950 }
36951 }
36952 }
36953 }
36954 }
36955 }
36956 }
36957 return false;
36958 }
36959
36960 private boolean jj_3R_296() {
36961 if (jj_scan_token(TIME)) return true;
36962 if (jj_scan_token(ZONE)) return true;
36963 Token xsp;
36964 xsp = jj_scanpos;
36965 if (jj_3R_470()) {
36966 jj_scanpos = xsp;
36967 if (jj_3R_471()) {
36968 jj_scanpos = xsp;
36969 if (jj_3R_472()) {
36970 jj_scanpos = xsp;
36971 if (jj_3R_473()) return true;
36972 }
36973 }
36974 }
36975 return false;
36976 }
36977
36978 private boolean jj_3R_469() {
36979 if (jj_3R_123()) return true;
36980 Token xsp;
36981 xsp = jj_scanpos;
36982 if (jj_3_25()) jj_scanpos = xsp;
36983 xsp = jj_scanpos;
36984 if (jj_scan_token(8)) {
36985 jj_scanpos = xsp;
36986 if (jj_3R_554()) return true;
36987 }
36988 xsp = jj_scanpos;
36989 if (jj_3R_555()) jj_scanpos = xsp;
36990 return false;
36991 }
36992
36993 private boolean jj_3R_224() {
36994 if (jj_3R_297()) return true;
36995 return false;
36996 }
36997
36998 private boolean jj_3R_295() {
36999 if (jj_scan_token(LOCAL)) return true;
37000 return false;
37001 }
37002
37003 private boolean jj_3R_510() {
37004 if (jj_scan_token(3)) return true;
37005 if (jj_3R_123()) return true;
37006 return false;
37007 }
37008
37009 private boolean jj_3R_330() {
37010 if (jj_3R_190()) return true;
37011 if (jj_scan_token(BEGIN)) return true;
37012 Token xsp;
37013 while (true) {
37014 xsp = jj_scanpos;
37015 if (jj_3R_456()) { jj_scanpos = xsp; break; }
37016 }
37017 xsp = jj_scanpos;
37018 if (jj_3R_457()) jj_scanpos = xsp;
37019 if (jj_scan_token(END)) return true;
37020 xsp = jj_scanpos;
37021 if (jj_3R_458()) jj_scanpos = xsp;
37022 return false;
37023 }
37024
37025 private boolean jj_3_21() {
37026 if (jj_3R_122()) return true;
37027 return false;
37028 }
37029
37030 private boolean jj_3_22() {
37031 if (jj_3R_123()) return true;
37032 if (jj_scan_token(3)) return true;
37033 return false;
37034 }
37035
37036 private boolean jj_3R_153() {
37037 Token xsp;
37038 xsp = jj_scanpos;
37039 if (jj_3_22()) jj_scanpos = xsp;
37040 if (jj_3R_123()) return true;
37041 return false;
37042 }
37043
37044 private boolean jj_3R_223() {
37045 if (jj_scan_token(AT)) return true;
37046 Token xsp;
37047 xsp = jj_scanpos;
37048 if (jj_3R_295()) {
37049 jj_scanpos = xsp;
37050 if (jj_3R_296()) return true;
37051 }
37052 return false;
37053 }
37054
37055 private boolean jj_3R_386() {
37056 if (jj_scan_token(RELIES_ON)) return true;
37057 if (jj_scan_token(5)) return true;
37058 if (jj_3R_123()) return true;
37059 Token xsp;
37060 xsp = jj_scanpos;
37061 if (jj_3R_595()) jj_scanpos = xsp;
37062 while (true) {
37063 xsp = jj_scanpos;
37064 if (jj_3R_596()) { jj_scanpos = xsp; break; }
37065 }
37066 if (jj_scan_token(7)) return true;
37067 return false;
37068 }
37069
37070 private boolean jj_3R_222() {
37071 if (jj_scan_token(2)) return true;
37072 if (jj_3R_119()) return true;
37073 return false;
37074 }
37075
37076 private boolean jj_3R_383() {
37077 if (jj_3R_424()) return true;
37078 return false;
37079 }
37080
37081 private boolean jj_3R_236() {
37082 if (jj_3R_281()) return true;
37083 return false;
37084 }
37085
37086 private boolean jj_3R_426() {
37087 Token xsp;
37088 xsp = jj_scanpos;
37089 if (jj_scan_token(201)) {
37090 jj_scanpos = xsp;
37091 if (jj_scan_token(70)) return true;
37092 }
37093 xsp = jj_scanpos;
37094 if (jj_3R_511()) jj_scanpos = xsp;
37095 if (jj_scan_token(BY)) return true;
37096 if (jj_scan_token(5)) return true;
37097 if (jj_3R_123()) return true;
37098 while (true) {
37099 xsp = jj_scanpos;
37100 if (jj_3R_617()) { jj_scanpos = xsp; break; }
37101 }
37102 if (jj_scan_token(7)) return true;
37103 return false;
37104 }
37105
37106 private boolean jj_3R_221() {
37107 if (jj_scan_token(3)) return true;
37108 if (jj_3R_119()) return true;
37109 return false;
37110 }
37111
37112 private boolean jj_3R_280() {
37113 Token xsp;
37114 xsp = jj_scanpos;
37115 if (jj_scan_token(150)) {
37116 jj_scanpos = xsp;
37117 if (jj_scan_token(50)) return true;
37118 }
37119 xsp = jj_scanpos;
37120 if (jj_3_21()) {
37121 jj_scanpos = xsp;
37122 if (jj_3R_330()) return true;
37123 }
37124 return false;
37125 }
37126
37127 private boolean jj_3R_134() {
37128 Token xsp;
37129 xsp = jj_scanpos;
37130 if (jj_3R_221()) {
37131 jj_scanpos = xsp;
37132 if (jj_3R_222()) {
37133 jj_scanpos = xsp;
37134 if (jj_3R_223()) {
37135 jj_scanpos = xsp;
37136 if (jj_3R_224()) return true;
37137 }
37138 }
37139 }
37140 return false;
37141 }
37142
37143 private boolean jj_3R_425() {
37144 if (jj_scan_token(USING)) return true;
37145 if (jj_3R_123()) return true;
37146 Token xsp;
37147 xsp = jj_scanpos;
37148 if (jj_3R_510()) jj_scanpos = xsp;
37149 return false;
37150 }
37151
37152 private boolean jj_3R_385() {
37153 Token xsp;
37154 xsp = jj_scanpos;
37155 if (jj_3R_425()) {
37156 jj_scanpos = xsp;
37157 if (jj_3R_426()) return true;
37158 }
37159 return false;
37160 }
37161
37162 private boolean jj_3R_275() {
37163 Token xsp;
37164 xsp = jj_scanpos;
37165 if (jj_scan_token(99)) {
37166 jj_scanpos = xsp;
37167 if (jj_scan_token(180)) return true;
37168 }
37169 return false;
37170 }
37171
37172 private boolean jj_3_55() {
37173 Token xsp;
37174 if (jj_scan_token(5)) return true;
37175 while (true) {
37176 xsp = jj_scanpos;
37177 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37178 }
37179 if (jj_scan_token(WITH)) return true;
37180 return false;
37181 }
37182
37183 private boolean jj_3R_141() {
37184 Token xsp;
37185 xsp = jj_scanpos;
37186 if (jj_scan_token(417)) {
37187 jj_scanpos = xsp;
37188 if (jj_scan_token(425)) {
37189 jj_scanpos = xsp;
37190 if (jj_3R_236()) {
37191 jj_scanpos = xsp;
37192 if (jj_scan_token(59)) {
37193 jj_scanpos = xsp;
37194 if (jj_scan_token(169)) {
37195 jj_scanpos = xsp;
37196 if (jj_scan_token(198)) {
37197 jj_scanpos = xsp;
37198 if (jj_scan_token(219)) {
37199 jj_scanpos = xsp;
37200 if (jj_scan_token(224)) {
37201 jj_scanpos = xsp;
37202 if (jj_scan_token(35)) {
37203 jj_scanpos = xsp;
37204 if (jj_scan_token(305)) {
37205 jj_scanpos = xsp;
37206 if (jj_scan_token(255)) {
37207 jj_scanpos = xsp;
37208 if (jj_scan_token(256)) {
37209 jj_scanpos = xsp;
37210 if (jj_scan_token(257)) {
37211 jj_scanpos = xsp;
37212 if (jj_scan_token(266)) {
37213 jj_scanpos = xsp;
37214 if (jj_scan_token(281)) {
37215 jj_scanpos = xsp;
37216 if (jj_scan_token(159)) {
37217 jj_scanpos = xsp;
37218 if (jj_scan_token(300)) {
37219 jj_scanpos = xsp;
37220 if (jj_scan_token(49)) return true;
37221 }
37222 }
37223 }
37224 }
37225 }
37226 }
37227 }
37228 }
37229 }
37230 }
37231 }
37232 }
37233 }
37234 }
37235 }
37236 }
37237 }
37238 return false;
37239 }
37240
37241 private boolean jj_3_54() {
37242 if (jj_scan_token(WITH)) return true;
37243 return false;
37244 }
37245
37246 private boolean jj_3R_279() {
37247 if (jj_scan_token(AGGREGATE)) return true;
37248 if (jj_scan_token(USING)) return true;
37249 if (jj_3R_123()) return true;
37250 return false;
37251 }
37252
37253 private boolean jj_3R_329() {
37254 if (jj_scan_token(RESULT_CACHE)) return true;
37255 Token xsp;
37256 xsp = jj_scanpos;
37257 if (jj_3R_386()) jj_scanpos = xsp;
37258 return false;
37259 }
37260
37261 private boolean jj_3_53() {
37262 Token xsp;
37263 if (jj_scan_token(5)) return true;
37264 while (true) {
37265 xsp = jj_scanpos;
37266 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
37267 }
37268 if (jj_scan_token(SELECT)) return true;
37269 return false;
37270 }
37271
37272 private boolean jj_3_52() {
37273 if (jj_scan_token(SELECT)) return true;
37274 return false;
37275 }
37276
37277 private boolean jj_3R_294() {
37278 if (jj_scan_token(6)) return true;
37279 if (jj_3R_232()) return true;
37280 return false;
37281 }
37282
37283 private boolean jj_3R_328() {
37284 if (jj_scan_token(PIPELINED)) return true;
37285 Token xsp;
37286 xsp = jj_scanpos;
37287 if (jj_3R_385()) jj_scanpos = xsp;
37288 return false;
37289 }
37290
37291 private boolean jj_3_51() {
37292 if (jj_3R_138()) return true;
37293 return false;
37294 }
37295
37296 private boolean jj_3R_327() {
37297 if (jj_scan_token(PARALLEL_ENABLE)) return true;
37298 Token xsp;
37299 xsp = jj_scanpos;
37300 if (jj_3R_383()) jj_scanpos = xsp;
37301 xsp = jj_scanpos;
37302 if (jj_3R_384()) jj_scanpos = xsp;
37303 return false;
37304 }
37305
37306 private boolean jj_3_50() {
37307 if (jj_3R_137()) return true;
37308 return false;
37309 }
37310
37311 private boolean jj_3R_326() {
37312 if (jj_3R_237()) return true;
37313 return false;
37314 }
37315
37316 private boolean jj_3R_220() {
37317 if (jj_scan_token(5)) return true;
37318 if (jj_3R_232()) return true;
37319 Token xsp;
37320 while (true) {
37321 xsp = jj_scanpos;
37322 if (jj_3R_294()) { jj_scanpos = xsp; break; }
37323 }
37324 if (jj_scan_token(7)) return true;
37325 return false;
37326 }
37327
37328 private boolean jj_3_49() {
37329 if (jj_3R_136()) return true;
37330 return false;
37331 }
37332
37333 private boolean jj_3_48() {
37334 if (jj_3R_135()) return true;
37335 return false;
37336 }
37337
37338 private boolean jj_3R_219() {
37339 if (jj_scan_token(5)) return true;
37340 if (jj_3R_178()) return true;
37341 if (jj_scan_token(7)) return true;
37342 return false;
37343 }
37344
37345 private boolean jj_3R_218() {
37346 if (jj_scan_token(WITH)) return true;
37347 if (jj_3R_178()) return true;
37348 return false;
37349 }
37350
37351 private boolean jj_3R_278() {
37352 Token xsp;
37353 xsp = jj_scanpos;
37354 if (jj_3R_325()) {
37355 jj_scanpos = xsp;
37356 if (jj_scan_token(94)) {
37357 jj_scanpos = xsp;
37358 if (jj_3R_326()) {
37359 jj_scanpos = xsp;
37360 if (jj_3R_327()) {
37361 jj_scanpos = xsp;
37362 if (jj_3R_328()) {
37363 jj_scanpos = xsp;
37364 if (jj_3R_329()) return true;
37365 }
37366 }
37367 }
37368 }
37369 }
37370 return false;
37371 }
37372
37373 private boolean jj_3R_325() {
37374 if (jj_scan_token(AUTHID)) return true;
37375 Token xsp;
37376 xsp = jj_scanpos;
37377 if (jj_scan_token(37)) {
37378 jj_scanpos = xsp;
37379 if (jj_scan_token(36)) return true;
37380 }
37381 return false;
37382 }
37383
37384 private boolean jj_3R_217() {
37385 if (jj_scan_token(5)) return true;
37386 if (jj_3R_178()) return true;
37387 if (jj_scan_token(7)) return true;
37388 return false;
37389 }
37390
37391 private boolean jj_3R_216() {
37392 if (jj_scan_token(SELECT)) return true;
37393 if (jj_3R_178()) return true;
37394 return false;
37395 }
37396
37397 private boolean jj_3R_194() {
37398 Token xsp;
37399 while (true) {
37400 xsp = jj_scanpos;
37401 if (jj_3R_278()) { jj_scanpos = xsp; break; }
37402 }
37403 xsp = jj_scanpos;
37404 if (jj_3R_279()) jj_scanpos = xsp;
37405 xsp = jj_scanpos;
37406 if (jj_3R_280()) jj_scanpos = xsp;
37407 if (jj_scan_token(4)) return true;
37408 return false;
37409 }
37410
37411 private boolean jj_3R_215() {
37412 if (jj_3R_293()) return true;
37413 return false;
37414 }
37415
37416 private boolean jj_3R_274() {
37417 if (jj_scan_token(OR)) return true;
37418 if (jj_scan_token(REPLACE)) return true;
37419 return false;
37420 }
37421
37422 private boolean jj_3R_214() {
37423 if (jj_3R_138()) return true;
37424 return false;
37425 }
37426
37427 private boolean jj_3R_213() {
37428 if (jj_3R_137()) return true;
37429 return false;
37430 }
37431
37432 private boolean jj_3R_212() {
37433 if (jj_3R_136()) return true;
37434 return false;
37435 }
37436
37437 private boolean jj_3R_211() {
37438 if (jj_3R_135()) return true;
37439 return false;
37440 }
37441
37442 private boolean jj_3R_210() {
37443 if (jj_3R_292()) return true;
37444 return false;
37445 }
37446
37447 private boolean jj_3R_193() {
37448 if (jj_3R_247()) return true;
37449 return false;
37450 }
37451
37452 private boolean jj_3R_133() {
37453 Token xsp;
37454 xsp = jj_scanpos;
37455 if (jj_3R_210()) {
37456 jj_scanpos = xsp;
37457 if (jj_3R_211()) {
37458 jj_scanpos = xsp;
37459 if (jj_3R_212()) {
37460 jj_scanpos = xsp;
37461 if (jj_3R_213()) {
37462 jj_scanpos = xsp;
37463 if (jj_3R_214()) {
37464 jj_scanpos = xsp;
37465 if (jj_3R_215()) {
37466 jj_scanpos = xsp;
37467 if (jj_3R_216()) {
37468 jj_scanpos = xsp;
37469 if (jj_3R_217()) {
37470 jj_scanpos = xsp;
37471 if (jj_3R_218()) {
37472 jj_scanpos = xsp;
37473 if (jj_3R_219()) {
37474 jj_scanpos = xsp;
37475 if (jj_3R_220()) return true;
37476 }
37477 }
37478 }
37479 }
37480 }
37481 }
37482 }
37483 }
37484 }
37485 }
37486 return false;
37487 }
37488
37489 private boolean jj_3_47() {
37490 if (jj_3R_134()) return true;
37491 return false;
37492 }
37493
37494 private boolean jj_3_46() {
37495 if (jj_scan_token(NEW)) return true;
37496 if (jj_3R_133()) return true;
37497 return false;
37498 }
37499
37500 private boolean jj_3R_191() {
37501 if (jj_scan_token(CREATE)) return true;
37502 Token xsp;
37503 xsp = jj_scanpos;
37504 if (jj_3R_274()) jj_scanpos = xsp;
37505 xsp = jj_scanpos;
37506 if (jj_3R_275()) jj_scanpos = xsp;
37507 return false;
37508 }
37509
37510 private boolean jj_3R_291() {
37511 if (jj_3R_133()) return true;
37512 return false;
37513 }
37514
37515 private boolean jj_3R_117() {
37516 Token xsp;
37517 xsp = jj_scanpos;
37518 if (jj_3R_191()) jj_scanpos = xsp;
37519 if (jj_3R_192()) return true;
37520 xsp = jj_scanpos;
37521 if (jj_3R_193()) {
37522 jj_scanpos = xsp;
37523 if (jj_3R_194()) return true;
37524 }
37525 return false;
37526 }
37527
37528 private boolean jj_3R_290() {
37529 if (jj_scan_token(NEW)) return true;
37530 if (jj_3R_133()) return true;
37531 return false;
37532 }
37533
37534 private boolean jj_3R_209() {
37535 Token xsp;
37536 xsp = jj_scanpos;
37537 if (jj_3R_290()) {
37538 jj_scanpos = xsp;
37539 if (jj_3R_291()) return true;
37540 }
37541 while (true) {
37542 xsp = jj_scanpos;
37543 if (jj_3_47()) { jj_scanpos = xsp; break; }
37544 }
37545 return false;
37546 }
37547
37548 private boolean jj_3R_529() {
37549 if (jj_scan_token(CC_ERROR)) return true;
37550 if (jj_3R_232()) return true;
37551 if (jj_scan_token(CC_END)) return true;
37552 return false;
37553 }
37554
37555 private boolean jj_3R_208() {
37556 if (jj_scan_token(NEW_DOT)) return true;
37557 if (jj_3R_119()) return true;
37558 return false;
37559 }
37560
37561 private boolean jj_3R_528() {
37562 if (jj_3R_321()) return true;
37563 return false;
37564 }
37565
37566 private boolean jj_3R_500() {
37567 Token xsp;
37568 xsp = jj_scanpos;
37569 if (jj_3R_528()) {
37570 jj_scanpos = xsp;
37571 if (jj_3R_529()) return true;
37572 }
37573 return false;
37574 }
37575
37576 private boolean jj_3R_132() {
37577 Token xsp;
37578 xsp = jj_scanpos;
37579 if (jj_3R_208()) {
37580 jj_scanpos = xsp;
37581 if (jj_3R_209()) return true;
37582 }
37583 return false;
37584 }
37585
37586 private boolean jj_3R_468() {
37587 if (jj_scan_token(CC_ELSE)) return true;
37588 Token xsp;
37589 while (true) {
37590 xsp = jj_scanpos;
37591 if (jj_3R_500()) { jj_scanpos = xsp; break; }
37592 }
37593 return false;
37594 }
37595
37596 private boolean jj_3R_527() {
37597 if (jj_scan_token(CC_ERROR)) return true;
37598 if (jj_3R_232()) return true;
37599 if (jj_scan_token(CC_END)) return true;
37600 return false;
37601 }
37602
37603 private boolean jj_3R_526() {
37604 if (jj_3R_321()) return true;
37605 return false;
37606 }
37607
37608 private boolean jj_3R_499() {
37609 Token xsp;
37610 xsp = jj_scanpos;
37611 if (jj_3R_526()) {
37612 jj_scanpos = xsp;
37613 if (jj_3R_527()) return true;
37614 }
37615 return false;
37616 }
37617
37618 private boolean jj_3R_467() {
37619 if (jj_scan_token(CC_ELSIF)) return true;
37620 if (jj_3R_342()) return true;
37621 if (jj_scan_token(CC_THEN)) return true;
37622 Token xsp;
37623 while (true) {
37624 xsp = jj_scanpos;
37625 if (jj_3R_499()) { jj_scanpos = xsp; break; }
37626 }
37627 return false;
37628 }
37629
37630 private boolean jj_3R_498() {
37631 if (jj_scan_token(CC_ERROR)) return true;
37632 if (jj_3R_232()) return true;
37633 if (jj_scan_token(CC_END)) return true;
37634 return false;
37635 }
37636
37637 private boolean jj_3R_252() {
37638 if (jj_3R_123()) return true;
37639 return false;
37640 }
37641
37642 private boolean jj_3R_497() {
37643 if (jj_3R_321()) return true;
37644 return false;
37645 }
37646
37647 private boolean jj_3R_466() {
37648 Token xsp;
37649 xsp = jj_scanpos;
37650 if (jj_3R_497()) {
37651 jj_scanpos = xsp;
37652 if (jj_3R_498()) return true;
37653 }
37654 return false;
37655 }
37656
37657 private boolean jj_3R_584() {
37658 if (jj_3R_132()) return true;
37659 return false;
37660 }
37661
37662 private boolean jj_3R_583() {
37663 if (jj_scan_token(NOT)) return true;
37664 if (jj_3R_478()) return true;
37665 return false;
37666 }
37667
37668 private boolean jj_3R_539() {
37669 Token xsp;
37670 xsp = jj_scanpos;
37671 if (jj_3R_583()) {
37672 jj_scanpos = xsp;
37673 if (jj_3R_584()) return true;
37674 }
37675 return false;
37676 }
37677
37678 private boolean jj_3R_422() {
37679 if (jj_scan_token(CC_IF)) return true;
37680 if (jj_3R_342()) return true;
37681 if (jj_scan_token(CC_THEN)) return true;
37682 Token xsp;
37683 while (true) {
37684 xsp = jj_scanpos;
37685 if (jj_3R_466()) { jj_scanpos = xsp; break; }
37686 }
37687 while (true) {
37688 xsp = jj_scanpos;
37689 if (jj_3R_467()) { jj_scanpos = xsp; break; }
37690 }
37691 while (true) {
37692 xsp = jj_scanpos;
37693 if (jj_3R_468()) { jj_scanpos = xsp; break; }
37694 }
37695 if (jj_scan_token(CC_END)) return true;
37696 return false;
37697 }
37698
37699 private boolean jj_3R_273() {
37700 if (jj_3R_321()) return true;
37701 return false;
37702 }
37703
37704 private boolean jj_3R_508() {
37705 if (jj_3R_539()) return true;
37706 return false;
37707 }
37708
37709 private boolean jj_3R_538() {
37710 if (jj_scan_token(17)) return true;
37711 return false;
37712 }
37713
37714 private boolean jj_3R_537() {
37715 if (jj_scan_token(16)) return true;
37716 return false;
37717 }
37718
37719 private boolean jj_3R_381() {
37720 if (jj_3R_422()) return true;
37721 return false;
37722 }
37723
37724 private boolean jj_3R_190() {
37725 Token xsp;
37726 while (true) {
37727 xsp = jj_scanpos;
37728 if (jj_3R_273()) { jj_scanpos = xsp; break; }
37729 }
37730 return false;
37731 }
37732
37733 private boolean jj_3R_507() {
37734 Token xsp;
37735 xsp = jj_scanpos;
37736 if (jj_3R_537()) {
37737 jj_scanpos = xsp;
37738 if (jj_3R_538()) return true;
37739 }
37740 if (jj_3R_478()) return true;
37741 return false;
37742 }
37743
37744 private boolean jj_3R_380() {
37745 if (jj_3R_421()) return true;
37746 return false;
37747 }
37748
37749 private boolean jj_3_18() {
37750 Token xsp;
37751 xsp = jj_scanpos;
37752 if (jj_scan_token(124)) {
37753 jj_scanpos = xsp;
37754 if (jj_scan_token(220)) return true;
37755 }
37756 if (jj_3R_119()) return true;
37757 return false;
37758 }
37759
37760 private boolean jj_3_17() {
37761 Token xsp;
37762 xsp = jj_scanpos;
37763 if (jj_scan_token(281)) {
37764 jj_scanpos = xsp;
37765 if (jj_scan_token(261)) return true;
37766 }
37767 if (jj_3R_119()) return true;
37768 xsp = jj_scanpos;
37769 if (jj_scan_token(150)) {
37770 jj_scanpos = xsp;
37771 if (jj_scan_token(50)) return true;
37772 }
37773 return false;
37774 }
37775
37776 private boolean jj_3R_478() {
37777 Token xsp;
37778 xsp = jj_scanpos;
37779 if (jj_3R_507()) {
37780 jj_scanpos = xsp;
37781 if (jj_3R_508()) return true;
37782 }
37783 return false;
37784 }
37785
37786 private boolean jj_3R_379() {
37787 if (jj_3R_420()) return true;
37788 return false;
37789 }
37790
37791 private boolean jj_3R_378() {
37792 if (jj_3R_419()) return true;
37793 return false;
37794 }
37795
37796 private boolean jj_3_20() {
37797 if (jj_3R_121()) return true;
37798 return false;
37799 }
37800
37801 private boolean jj_3R_305() {
37802 if (jj_3R_348()) return true;
37803 return false;
37804 }
37805
37806 private boolean jj_3_19() {
37807 if (jj_3R_120()) return true;
37808 return false;
37809 }
37810
37811 private boolean jj_3R_377() {
37812 if (jj_3R_117()) return true;
37813 return false;
37814 }
37815
37816 private boolean jj_3R_603() {
37817 if (jj_scan_token(MOD)) return true;
37818 return false;
37819 }
37820
37821 private boolean jj_3R_602() {
37822 if (jj_scan_token(1)) return true;
37823 return false;
37824 }
37825
37826 private boolean jj_3R_376() {
37827 if (jj_3R_151()) return true;
37828 return false;
37829 }
37830
37831 private boolean jj_3R_601() {
37832 if (jj_scan_token(20)) return true;
37833 return false;
37834 }
37835
37836 private boolean jj_3R_600() {
37837 if (jj_scan_token(19)) return true;
37838 return false;
37839 }
37840
37841 private boolean jj_3_16() {
37842 if (jj_3R_118()) return true;
37843 return false;
37844 }
37845
37846 private boolean jj_3R_375() {
37847 if (jj_3R_418()) return true;
37848 return false;
37849 }
37850
37851 private boolean jj_3R_564() {
37852 Token xsp;
37853 xsp = jj_scanpos;
37854 if (jj_3R_600()) {
37855 jj_scanpos = xsp;
37856 if (jj_3R_601()) {
37857 jj_scanpos = xsp;
37858 if (jj_3R_602()) {
37859 jj_scanpos = xsp;
37860 if (jj_3R_603()) return true;
37861 }
37862 }
37863 }
37864 if (jj_3R_478()) return true;
37865 return false;
37866 }
37867
37868 private boolean jj_3_15() {
37869 if (jj_3R_117()) return true;
37870 return false;
37871 }
37872
37873 private boolean jj_3R_250() {
37874 Token xsp;
37875 xsp = jj_scanpos;
37876 if (jj_scan_token(99)) {
37877 jj_scanpos = xsp;
37878 if (jj_scan_token(180)) return true;
37879 }
37880 return false;
37881 }
37882
37883 private boolean jj_3R_304() {
37884 if (jj_3R_172()) return true;
37885 return false;
37886 }
37887
37888 private boolean jj_3R_531() {
37889 if (jj_3R_478()) return true;
37890 Token xsp;
37891 while (true) {
37892 xsp = jj_scanpos;
37893 if (jj_3R_564()) { jj_scanpos = xsp; break; }
37894 }
37895 return false;
37896 }
37897
37898 private boolean jj_3R_321() {
37899 Token xsp;
37900 xsp = jj_scanpos;
37901 if (jj_3R_375()) {
37902 jj_scanpos = xsp;
37903 if (jj_3_16()) {
37904 jj_scanpos = xsp;
37905 if (jj_3R_376()) {
37906 jj_scanpos = xsp;
37907 if (jj_3R_377()) {
37908 jj_scanpos = xsp;
37909 if (jj_3_19()) {
37910 jj_scanpos = xsp;
37911 if (jj_3_20()) {
37912 jj_scanpos = xsp;
37913 if (jj_3R_378()) {
37914 jj_scanpos = xsp;
37915 if (jj_3R_379()) {
37916 jj_scanpos = xsp;
37917 if (jj_3R_380()) {
37918 jj_scanpos = xsp;
37919 if (jj_3R_381()) return true;
37920 }
37921 }
37922 }
37923 }
37924 }
37925 }
37926 }
37927 }
37928 }
37929 return false;
37930 }
37931
37932 private boolean jj_3R_251() {
37933 if (jj_scan_token(BEGIN)) return true;
37934 Token xsp;
37935 while (true) {
37936 xsp = jj_scanpos;
37937 if (jj_3R_304()) { jj_scanpos = xsp; break; }
37938 }
37939 xsp = jj_scanpos;
37940 if (jj_3R_305()) jj_scanpos = xsp;
37941 return false;
37942 }
37943
37944 private boolean jj_3R_298() {
37945 if (jj_scan_token(18)) return true;
37946 if (jj_3R_132()) return true;
37947 return false;
37948 }
37949
37950 private boolean jj_3R_249() {
37951 if (jj_scan_token(OR)) return true;
37952 if (jj_scan_token(REPLACE)) return true;
37953 return false;
37954 }
37955
37956 private boolean jj_3R_159() {
37957 Token xsp;
37958 xsp = jj_scanpos;
37959 if (jj_scan_token(150)) {
37960 jj_scanpos = xsp;
37961 if (jj_scan_token(50)) return true;
37962 }
37963 if (jj_3R_190()) return true;
37964 xsp = jj_scanpos;
37965 if (jj_3R_251()) jj_scanpos = xsp;
37966 if (jj_scan_token(END)) return true;
37967 xsp = jj_scanpos;
37968 if (jj_3R_252()) jj_scanpos = xsp;
37969 if (jj_scan_token(4)) return true;
37970 return false;
37971 }
37972
37973 private boolean jj_3R_228() {
37974 if (jj_3R_132()) return true;
37975 Token xsp;
37976 while (true) {
37977 xsp = jj_scanpos;
37978 if (jj_3R_298()) { jj_scanpos = xsp; break; }
37979 }
37980 return false;
37981 }
37982
37983 private boolean jj_3R_158() {
37984 if (jj_3R_247()) return true;
37985 return false;
37986 }
37987
37988 private boolean jj_3R_269() {
37989 if (jj_3R_189()) return true;
37990 return false;
37991 }
37992
37993 private boolean jj_3R_567() {
37994 if (jj_scan_token(18)) return true;
37995 return false;
37996 }
37997
37998 private boolean jj_3R_566() {
37999 if (jj_scan_token(17)) return true;
38000 return false;
38001 }
38002
38003 private boolean jj_3R_157() {
38004 if (jj_scan_token(CREATE)) return true;
38005 Token xsp;
38006 xsp = jj_scanpos;
38007 if (jj_3R_249()) jj_scanpos = xsp;
38008 xsp = jj_scanpos;
38009 if (jj_3R_250()) jj_scanpos = xsp;
38010 return false;
38011 }
38012
38013 private boolean jj_3R_565() {
38014 if (jj_scan_token(16)) return true;
38015 return false;
38016 }
38017
38018 private boolean jj_3R_532() {
38019 Token xsp;
38020 xsp = jj_scanpos;
38021 if (jj_3R_565()) {
38022 jj_scanpos = xsp;
38023 if (jj_3R_566()) {
38024 jj_scanpos = xsp;
38025 if (jj_3R_567()) return true;
38026 }
38027 }
38028 if (jj_3R_531()) return true;
38029 return false;
38030 }
38031
38032 private boolean jj_3R_244() {
38033 Token xsp;
38034 xsp = jj_scanpos;
38035 if (jj_scan_token(99)) {
38036 jj_scanpos = xsp;
38037 if (jj_scan_token(180)) return true;
38038 }
38039 return false;
38040 }
38041
38042 private boolean jj_3R_248() {
38043 if (jj_3R_123()) return true;
38044 return false;
38045 }
38046
38047 private boolean jj_3R_103() {
38048 Token xsp;
38049 xsp = jj_scanpos;
38050 if (jj_3R_157()) jj_scanpos = xsp;
38051 xsp = jj_scanpos;
38052 if (jj_scan_token(206)) {
38053 jj_scanpos = xsp;
38054 if (jj_scan_token(281)) return true;
38055 }
38056 if (jj_scan_token(BODY)) return true;
38057 if (jj_3R_153()) return true;
38058 xsp = jj_scanpos;
38059 if (jj_3R_158()) {
38060 jj_scanpos = xsp;
38061 if (jj_3R_159()) return true;
38062 }
38063 return false;
38064 }
38065
38066 private boolean jj_3R_502() {
38067 if (jj_3R_531()) return true;
38068 Token xsp;
38069 while (true) {
38070 xsp = jj_scanpos;
38071 if (jj_3R_532()) { jj_scanpos = xsp; break; }
38072 }
38073 return false;
38074 }
38075
38076 private boolean jj_3R_582() {
38077 if (jj_3R_181()) return true;
38078 return false;
38079 }
38080
38081 private boolean jj_3R_581() {
38082 if (jj_scan_token(CHARACTER_LITERAL)) return true;
38083 return false;
38084 }
38085
38086 private boolean jj_3R_536() {
38087 if (jj_scan_token(ESCAPE)) return true;
38088 Token xsp;
38089 xsp = jj_scanpos;
38090 if (jj_3R_581()) {
38091 jj_scanpos = xsp;
38092 if (jj_3R_582()) return true;
38093 }
38094 return false;
38095 }
38096
38097 private boolean jj_3R_156() {
38098 Token xsp;
38099 xsp = jj_scanpos;
38100 if (jj_scan_token(150)) {
38101 jj_scanpos = xsp;
38102 if (jj_scan_token(50)) return true;
38103 }
38104 if (jj_3R_190()) return true;
38105 if (jj_scan_token(END)) return true;
38106 xsp = jj_scanpos;
38107 if (jj_3R_248()) jj_scanpos = xsp;
38108 if (jj_scan_token(4)) return true;
38109 return false;
38110 }
38111
38112 private boolean jj_3R_609() {
38113 if (jj_scan_token(ALL)) return true;
38114 return false;
38115 }
38116
38117 private boolean jj_3R_608() {
38118 if (jj_scan_token(DISTINCT)) return true;
38119 return false;
38120 }
38121
38122 private boolean jj_3R_580() {
38123 Token xsp;
38124 xsp = jj_scanpos;
38125 if (jj_3R_608()) {
38126 jj_scanpos = xsp;
38127 if (jj_3R_609()) return true;
38128 }
38129 return false;
38130 }
38131
38132 private boolean jj_3R_155() {
38133 if (jj_3R_247()) return true;
38134 return false;
38135 }
38136
38137 private boolean jj_3R_243() {
38138 if (jj_scan_token(OR)) return true;
38139 if (jj_scan_token(REPLACE)) return true;
38140 return false;
38141 }
38142
38143 private boolean jj_3R_579() {
38144 if (jj_scan_token(UNION)) return true;
38145 return false;
38146 }
38147
38148 private boolean jj_3R_246() {
38149 if (jj_3R_237()) return true;
38150 return false;
38151 }
38152
38153 private boolean jj_3R_578() {
38154 if (jj_scan_token(INTERSECT)) return true;
38155 return false;
38156 }
38157
38158 private boolean jj_3R_577() {
38159 if (jj_scan_token(EXCEPT)) return true;
38160 return false;
38161 }
38162
38163 private boolean jj_3R_154() {
38164 Token xsp;
38165 xsp = jj_scanpos;
38166 if (jj_3R_245()) {
38167 jj_scanpos = xsp;
38168 if (jj_3R_246()) return true;
38169 }
38170 return false;
38171 }
38172
38173 private boolean jj_3R_245() {
38174 if (jj_scan_token(AUTHID)) return true;
38175 Token xsp;
38176 xsp = jj_scanpos;
38177 if (jj_scan_token(37)) {
38178 jj_scanpos = xsp;
38179 if (jj_scan_token(36)) return true;
38180 }
38181 return false;
38182 }
38183
38184 private boolean jj_3R_607() {
38185 if (jj_scan_token(OF)) return true;
38186 return false;
38187 }
38188
38189 private boolean jj_3R_152() {
38190 if (jj_scan_token(CREATE)) return true;
38191 Token xsp;
38192 xsp = jj_scanpos;
38193 if (jj_3R_243()) jj_scanpos = xsp;
38194 xsp = jj_scanpos;
38195 if (jj_3R_244()) jj_scanpos = xsp;
38196 return false;
38197 }
38198
38199 private boolean jj_3R_535() {
38200 if (jj_scan_token(MULTISET)) return true;
38201 Token xsp;
38202 xsp = jj_scanpos;
38203 if (jj_3R_577()) {
38204 jj_scanpos = xsp;
38205 if (jj_3R_578()) {
38206 jj_scanpos = xsp;
38207 if (jj_3R_579()) return true;
38208 }
38209 }
38210 xsp = jj_scanpos;
38211 if (jj_3R_580()) jj_scanpos = xsp;
38212 return false;
38213 }
38214
38215 private boolean jj_3R_606() {
38216 if (jj_scan_token(SUBMULTISET)) return true;
38217 return false;
38218 }
38219
38220 private boolean jj_3R_605() {
38221 if (jj_scan_token(MEMBER)) return true;
38222 return false;
38223 }
38224
38225 private boolean jj_3R_102() {
38226 Token xsp;
38227 xsp = jj_scanpos;
38228 if (jj_3R_152()) jj_scanpos = xsp;
38229 if (jj_scan_token(PACKAGE)) return true;
38230 if (jj_3R_153()) return true;
38231 while (true) {
38232 xsp = jj_scanpos;
38233 if (jj_3R_154()) { jj_scanpos = xsp; break; }
38234 }
38235 xsp = jj_scanpos;
38236 if (jj_3R_155()) {
38237 jj_scanpos = xsp;
38238 if (jj_3R_156()) return true;
38239 }
38240 return false;
38241 }
38242
38243 private boolean jj_3R_116() {
38244 if (jj_scan_token(DECLARE)) return true;
38245 if (jj_3R_190()) return true;
38246 return false;
38247 }
38248
38249 private boolean jj_3R_576() {
38250 Token xsp;
38251 xsp = jj_scanpos;
38252 if (jj_3R_605()) {
38253 jj_scanpos = xsp;
38254 if (jj_3R_606()) return true;
38255 }
38256 xsp = jj_scanpos;
38257 if (jj_3R_607()) jj_scanpos = xsp;
38258 return false;
38259 }
38260
38261 private boolean jj_3R_575() {
38262 if (jj_scan_token(FROM)) return true;
38263 return false;
38264 }
38265
38266 private boolean jj_3R_574() {
38267 if (jj_scan_token(LIKE)) return true;
38268 return false;
38269 }
38270
38271 private boolean jj_3R_573() {
38272 if (jj_scan_token(BETWEEN)) return true;
38273 return false;
38274 }
38275
38276 private boolean jj_3R_572() {
38277 if (jj_scan_token(IN)) return true;
38278 return false;
38279 }
38280
38281 private boolean jj_3R_604() {
38282 if (jj_scan_token(15)) return true;
38283 return false;
38284 }
38285
38286 private boolean jj_3R_571() {
38287 if (jj_scan_token(NOT)) return true;
38288 return false;
38289 }
38290
38291 private boolean jj_3R_570() {
38292 if (jj_scan_token(10)) return true;
38293 return false;
38294 }
38295
38296 private boolean jj_3R_569() {
38297 if (jj_scan_token(15)) return true;
38298 return false;
38299 }
38300
38301 private boolean jj_3R_534() {
38302 Token xsp;
38303 xsp = jj_scanpos;
38304 if (jj_3R_571()) jj_scanpos = xsp;
38305 xsp = jj_scanpos;
38306 if (jj_3R_572()) {
38307 jj_scanpos = xsp;
38308 if (jj_3R_573()) {
38309 jj_scanpos = xsp;
38310 if (jj_3R_574()) {
38311 jj_scanpos = xsp;
38312 if (jj_3R_575()) {
38313 jj_scanpos = xsp;
38314 if (jj_3R_576()) return true;
38315 }
38316 }
38317 }
38318 }
38319 return false;
38320 }
38321
38322 private boolean jj_3R_320() {
38323 if (jj_3R_348()) return true;
38324 return false;
38325 }
38326
38327 private boolean jj_3R_319() {
38328 if (jj_3R_172()) return true;
38329 return false;
38330 }
38331
38332 private boolean jj_3R_568() {
38333 if (jj_scan_token(14)) return true;
38334 Token xsp;
38335 xsp = jj_scanpos;
38336 if (jj_3R_604()) jj_scanpos = xsp;
38337 return false;
38338 }
38339
38340 private boolean jj_3R_115() {
38341 if (jj_3R_189()) return true;
38342 return false;
38343 }
38344
38345 private boolean jj_3_14() {
38346 Token xsp;
38347 while (true) {
38348 xsp = jj_scanpos;
38349 if (jj_3R_115()) { jj_scanpos = xsp; break; }
38350 }
38351 xsp = jj_scanpos;
38352 if (jj_3R_116()) jj_scanpos = xsp;
38353 if (jj_scan_token(BEGIN)) return true;
38354 return false;
38355 }
38356
38357 private boolean jj_3R_318() {
38358 if (jj_scan_token(DECLARE)) return true;
38359 if (jj_3R_190()) return true;
38360 return false;
38361 }
38362
38363 private boolean jj_3R_270() {
38364 Token xsp;
38365 xsp = jj_scanpos;
38366 if (jj_3R_318()) jj_scanpos = xsp;
38367 if (jj_scan_token(BEGIN)) return true;
38368 while (true) {
38369 xsp = jj_scanpos;
38370 if (jj_3R_319()) { jj_scanpos = xsp; break; }
38371 }
38372 xsp = jj_scanpos;
38373 if (jj_3R_320()) jj_scanpos = xsp;
38374 if (jj_scan_token(END)) return true;
38375 xsp = jj_scanpos;
38376 if (jj_scan_token(417)) jj_scanpos = xsp;
38377 return false;
38378 }
38379
38380 private boolean jj_3R_533() {
38381 Token xsp;
38382 xsp = jj_scanpos;
38383 if (jj_3R_568()) {
38384 jj_scanpos = xsp;
38385 if (jj_3R_569()) return true;
38386 }
38387 xsp = jj_scanpos;
38388 if (jj_3R_570()) jj_scanpos = xsp;
38389 return false;
38390 }
38391
38392 private boolean jj_3R_503() {
38393 Token xsp;
38394 xsp = jj_scanpos;
38395 if (jj_3R_533()) {
38396 jj_scanpos = xsp;
38397 if (jj_3R_534()) {
38398 jj_scanpos = xsp;
38399 if (jj_3R_535()) return true;
38400 }
38401 }
38402 if (jj_3R_502()) return true;
38403 xsp = jj_scanpos;
38404 if (jj_3R_536()) jj_scanpos = xsp;
38405 return false;
38406 }
38407
38408 private boolean jj_3R_200() {
38409 if (jj_3R_281()) return true;
38410 return false;
38411 }
38412
38413 private boolean jj_3R_184() {
38414 Token xsp;
38415 while (true) {
38416 xsp = jj_scanpos;
38417 if (jj_3R_269()) { jj_scanpos = xsp; break; }
38418 }
38419 if (jj_3R_270()) return true;
38420 if (jj_scan_token(4)) return true;
38421 return false;
38422 }
38423
38424 private boolean jj_3R_476() {
38425 if (jj_3R_502()) return true;
38426 Token xsp;
38427 while (true) {
38428 xsp = jj_scanpos;
38429 if (jj_3R_503()) { jj_scanpos = xsp; break; }
38430 }
38431 return false;
38432 }
38433
38434 private boolean jj_3R_112() {
38435 Token xsp;
38436 xsp = jj_scanpos;
38437 if (jj_3R_184()) {
38438 jj_scanpos = xsp;
38439 if (jj_3_15()) return true;
38440 }
38441 return false;
38442 }
38443
38444 private boolean jj_3R_506() {
38445 if (jj_scan_token(IS)) return true;
38446 return false;
38447 }
38448
38449 private boolean jj_3R_123() {
38450 Token xsp;
38451 xsp = jj_scanpos;
38452 if (jj_scan_token(417)) {
38453 jj_scanpos = xsp;
38454 if (jj_scan_token(425)) {
38455 jj_scanpos = xsp;
38456 if (jj_3R_200()) {
38457 jj_scanpos = xsp;
38458 if (jj_scan_token(35)) {
38459 jj_scanpos = xsp;
38460 if (jj_scan_token(38)) {
38461 jj_scanpos = xsp;
38462 if (jj_scan_token(39)) {
38463 jj_scanpos = xsp;
38464 if (jj_scan_token(40)) {
38465 jj_scanpos = xsp;
38466 if (jj_scan_token(41)) {
38467 jj_scanpos = xsp;
38468 if (jj_scan_token(45)) {
38469 jj_scanpos = xsp;
38470 if (jj_scan_token(46)) {
38471 jj_scanpos = xsp;
38472 if (jj_scan_token(47)) {
38473 jj_scanpos = xsp;
38474 if (jj_scan_token(48)) {
38475 jj_scanpos = xsp;
38476 if (jj_scan_token(49)) {
38477 jj_scanpos = xsp;
38478 if (jj_scan_token(50)) {
38479 jj_scanpos = xsp;
38480 if (jj_scan_token(51)) {
38481 jj_scanpos = xsp;
38482 if (jj_scan_token(55)) {
38483 jj_scanpos = xsp;
38484 if (jj_scan_token(57)) {
38485 jj_scanpos = xsp;
38486 if (jj_scan_token(58)) {
38487 jj_scanpos = xsp;
38488 if (jj_scan_token(59)) {
38489 jj_scanpos = xsp;
38490 if (jj_scan_token(60)) {
38491 jj_scanpos = xsp;
38492 if (jj_scan_token(62)) {
38493 jj_scanpos = xsp;
38494 if (jj_scan_token(65)) {
38495 jj_scanpos = xsp;
38496 if (jj_scan_token(66)) {
38497 jj_scanpos = xsp;
38498 if (jj_scan_token(67)) {
38499 jj_scanpos = xsp;
38500 if (jj_scan_token(68)) {
38501 jj_scanpos = xsp;
38502 if (jj_scan_token(70)) {
38503 jj_scanpos = xsp;
38504 if (jj_scan_token(76)) {
38505 jj_scanpos = xsp;
38506 if (jj_scan_token(77)) {
38507 jj_scanpos = xsp;
38508 if (jj_scan_token(78)) {
38509 jj_scanpos = xsp;
38510 if (jj_scan_token(82)) {
38511 jj_scanpos = xsp;
38512 if (jj_scan_token(84)) {
38513 jj_scanpos = xsp;
38514 if (jj_scan_token(87)) {
38515 jj_scanpos = xsp;
38516 if (jj_scan_token(89)) {
38517 jj_scanpos = xsp;
38518 if (jj_scan_token(90)) {
38519 jj_scanpos = xsp;
38520 if (jj_scan_token(91)) {
38521 jj_scanpos = xsp;
38522 if (jj_scan_token(92)) {
38523 jj_scanpos = xsp;
38524 if (jj_scan_token(93)) {
38525 jj_scanpos = xsp;
38526 if (jj_scan_token(96)) {
38527 jj_scanpos = xsp;
38528 if (jj_scan_token(97)) {
38529 jj_scanpos = xsp;
38530 if (jj_scan_token(98)) {
38531 jj_scanpos = xsp;
38532 if (jj_scan_token(101)) {
38533 jj_scanpos = xsp;
38534 if (jj_scan_token(102)) {
38535 jj_scanpos = xsp;
38536 if (jj_scan_token(107)) {
38537 jj_scanpos = xsp;
38538 if (jj_scan_token(109)) {
38539 jj_scanpos = xsp;
38540 if (jj_scan_token(110)) {
38541 jj_scanpos = xsp;
38542 if (jj_scan_token(111)) {
38543 jj_scanpos = xsp;
38544 if (jj_scan_token(117)) {
38545 jj_scanpos = xsp;
38546 if (jj_scan_token(119)) {
38547 jj_scanpos = xsp;
38548 if (jj_scan_token(120)) {
38549 jj_scanpos = xsp;
38550 if (jj_scan_token(121)) {
38551 jj_scanpos = xsp;
38552 if (jj_scan_token(123)) {
38553 jj_scanpos = xsp;
38554 if (jj_scan_token(126)) {
38555 jj_scanpos = xsp;
38556 if (jj_scan_token(127)) {
38557 jj_scanpos = xsp;
38558 if (jj_scan_token(130)) {
38559 jj_scanpos = xsp;
38560 if (jj_scan_token(134)) {
38561 jj_scanpos = xsp;
38562 if (jj_scan_token(136)) {
38563 jj_scanpos = xsp;
38564 if (jj_scan_token(137)) {
38565 jj_scanpos = xsp;
38566 if (jj_scan_token(142)) {
38567 jj_scanpos = xsp;
38568 if (jj_scan_token(144)) {
38569 jj_scanpos = xsp;
38570 if (jj_scan_token(145)) {
38571 jj_scanpos = xsp;
38572 if (jj_scan_token(146)) {
38573 jj_scanpos = xsp;
38574 if (jj_scan_token(148)) {
38575 jj_scanpos = xsp;
38576 if (jj_scan_token(150)) {
38577 jj_scanpos = xsp;
38578 if (jj_scan_token(154)) {
38579 jj_scanpos = xsp;
38580 if (jj_scan_token(156)) {
38581 jj_scanpos = xsp;
38582 if (jj_scan_token(157)) {
38583 jj_scanpos = xsp;
38584 if (jj_scan_token(158)) {
38585 jj_scanpos = xsp;
38586 if (jj_scan_token(159)) {
38587 jj_scanpos = xsp;
38588 if (jj_scan_token(165)) {
38589 jj_scanpos = xsp;
38590 if (jj_scan_token(169)) {
38591 jj_scanpos = xsp;
38592 if (jj_scan_token(170)) {
38593 jj_scanpos = xsp;
38594 if (jj_scan_token(173)) {
38595 jj_scanpos = xsp;
38596 if (jj_scan_token(176)) {
38597 jj_scanpos = xsp;
38598 if (jj_scan_token(179)) {
38599 jj_scanpos = xsp;
38600 if (jj_scan_token(181)) {
38601 jj_scanpos = xsp;
38602 if (jj_scan_token(182)) {
38603 jj_scanpos = xsp;
38604 if (jj_scan_token(183)) {
38605 jj_scanpos = xsp;
38606 if (jj_scan_token(185)) {
38607 jj_scanpos = xsp;
38608 if (jj_scan_token(190)) {
38609 jj_scanpos = xsp;
38610 if (jj_scan_token(192)) {
38611 jj_scanpos = xsp;
38612 if (jj_scan_token(193)) {
38613 jj_scanpos = xsp;
38614 if (jj_scan_token(195)) {
38615 jj_scanpos = xsp;
38616 if (jj_scan_token(186)) {
38617 jj_scanpos = xsp;
38618 if (jj_scan_token(187)) {
38619 jj_scanpos = xsp;
38620 if (jj_scan_token(188)) {
38621 jj_scanpos = xsp;
38622 if (jj_scan_token(189)) {
38623 jj_scanpos = xsp;
38624 if (jj_scan_token(198)) {
38625 jj_scanpos = xsp;
38626 if (jj_scan_token(199)) {
38627 jj_scanpos = xsp;
38628 if (jj_scan_token(200)) {
38629 jj_scanpos = xsp;
38630 if (jj_scan_token(201)) {
38631 jj_scanpos = xsp;
38632 if (jj_scan_token(204)) {
38633 jj_scanpos = xsp;
38634 if (jj_scan_token(209)) {
38635 jj_scanpos = xsp;
38636 if (jj_scan_token(212)) {
38637 jj_scanpos = xsp;
38638 if (jj_scan_token(213)) {
38639 jj_scanpos = xsp;
38640 if (jj_scan_token(214)) {
38641 jj_scanpos = xsp;
38642 if (jj_scan_token(217)) {
38643 jj_scanpos = xsp;
38644 if (jj_scan_token(219)) {
38645 jj_scanpos = xsp;
38646 if (jj_scan_token(218)) {
38647 jj_scanpos = xsp;
38648 if (jj_scan_token(221)) {
38649 jj_scanpos = xsp;
38650 if (jj_scan_token(222)) {
38651 jj_scanpos = xsp;
38652 if (jj_scan_token(224)) {
38653 jj_scanpos = xsp;
38654 if (jj_scan_token(243)) {
38655 jj_scanpos = xsp;
38656 if (jj_scan_token(247)) {
38657 jj_scanpos = xsp;
38658 if (jj_scan_token(249)) {
38659 jj_scanpos = xsp;
38660 if (jj_scan_token(252)) {
38661 jj_scanpos = xsp;
38662 if (jj_scan_token(253)) {
38663 jj_scanpos = xsp;
38664 if (jj_scan_token(255)) {
38665 jj_scanpos = xsp;
38666 if (jj_scan_token(256)) {
38667 jj_scanpos = xsp;
38668 if (jj_scan_token(257)) {
38669 jj_scanpos = xsp;
38670 if (jj_scan_token(258)) {
38671 jj_scanpos = xsp;
38672 if (jj_scan_token(260)) {
38673 jj_scanpos = xsp;
38674 if (jj_scan_token(264)) {
38675 jj_scanpos = xsp;
38676 if (jj_scan_token(265)) {
38677 jj_scanpos = xsp;
38678 if (jj_scan_token(266)) {
38679 jj_scanpos = xsp;
38680 if (jj_scan_token(268)) {
38681 jj_scanpos = xsp;
38682 if (jj_scan_token(270)) {
38683 jj_scanpos = xsp;
38684 if (jj_scan_token(277)) {
38685 jj_scanpos = xsp;
38686 if (jj_scan_token(279)) {
38687 jj_scanpos = xsp;
38688 if (jj_scan_token(281)) {
38689 jj_scanpos = xsp;
38690 if (jj_scan_token(282)) {
38691 jj_scanpos = xsp;
38692 if (jj_scan_token(294)) {
38693 jj_scanpos = xsp;
38694 if (jj_scan_token(295)) {
38695 jj_scanpos = xsp;
38696 if (jj_scan_token(296)) {
38697 jj_scanpos = xsp;
38698 if (jj_scan_token(300)) {
38699 jj_scanpos = xsp;
38700 if (jj_scan_token(302)) {
38701 jj_scanpos = xsp;
38702 if (jj_scan_token(305)) {
38703 jj_scanpos = xsp;
38704 if (jj_scan_token(315)) {
38705 jj_scanpos = xsp;
38706 if (jj_scan_token(289)) {
38707 jj_scanpos = xsp;
38708 if (jj_scan_token(429)) {
38709 jj_scanpos = xsp;
38710 if (jj_scan_token(426)) {
38711 jj_scanpos = xsp;
38712 if (jj_scan_token(427)) {
38713 jj_scanpos = xsp;
38714 if (jj_scan_token(428)) return true;
38715 }
38716 }
38717 }
38718 }
38719 }
38720 }
38721 }
38722 }
38723 }
38724 }
38725 }
38726 }
38727 }
38728 }
38729 }
38730 }
38731 }
38732 }
38733 }
38734 }
38735 }
38736 }
38737 }
38738 }
38739 }
38740 }
38741 }
38742 }
38743 }
38744 }
38745 }
38746 }
38747 }
38748 }
38749 }
38750 }
38751 }
38752 }
38753 }
38754 }
38755 }
38756 }
38757 }
38758 }
38759 }
38760 }
38761 }
38762 }
38763 }
38764 }
38765 }
38766 }
38767 }
38768 }
38769 }
38770 }
38771 }
38772 }
38773 }
38774 }
38775 }
38776 }
38777 }
38778 }
38779 }
38780 }
38781 }
38782 }
38783 }
38784 }
38785 }
38786 }
38787 }
38788 }
38789 }
38790 }
38791 }
38792 }
38793 }
38794 }
38795 }
38796 }
38797 }
38798 }
38799 }
38800 }
38801 }
38802 }
38803 }
38804 }
38805 }
38806 }
38807 }
38808 }
38809 }
38810 }
38811 }
38812 }
38813 }
38814 }
38815 }
38816 }
38817 }
38818 }
38819 }
38820 }
38821 }
38822 }
38823 }
38824 }
38825 }
38826 }
38827 }
38828 }
38829 }
38830 }
38831 }
38832 }
38833 }
38834 }
38835 }
38836 }
38837 }
38838 }
38839 }
38840 }
38841 }
38842 }
38843 }
38844 }
38845 }
38846 return false;
38847 }
38848
38849 private boolean jj_3R_505() {
38850 if (jj_scan_token(13)) return true;
38851 if (jj_scan_token(10)) return true;
38852 return false;
38853 }
38854
38855 private boolean jj_3R_504() {
38856 if (jj_scan_token(10)) return true;
38857 return false;
38858 }
38859
38860 private boolean jj_3R_477() {
38861 Token xsp;
38862 xsp = jj_scanpos;
38863 if (jj_3R_504()) {
38864 jj_scanpos = xsp;
38865 if (jj_3R_505()) {
38866 jj_scanpos = xsp;
38867 if (jj_3R_506()) return true;
38868 }
38869 }
38870 if (jj_3R_476()) return true;
38871 return false;
38872 }
38873
38874 private boolean jj_3R_432() {
38875 if (jj_3R_476()) return true;
38876 Token xsp;
38877 while (true) {
38878 xsp = jj_scanpos;
38879 if (jj_3R_477()) { jj_scanpos = xsp; break; }
38880 }
38881 return false;
38882 }
38883
38884 private boolean jj_3R_433() {
38885 if (jj_scan_token(AND)) return true;
38886 if (jj_3R_432()) return true;
38887 return false;
38888 }
38889
38890 private boolean jj_3R_391() {
38891 if (jj_3R_432()) return true;
38892 Token xsp;
38893 while (true) {
38894 xsp = jj_scanpos;
38895 if (jj_3R_433()) { jj_scanpos = xsp; break; }
38896 }
38897 return false;
38898 }
38899
38900 private boolean jj_3R_187() {
38901 if (jj_scan_token(3)) return true;
38902 if (jj_scan_token(ATTACH)) return true;
38903 return false;
38904 }
38905
38906 private boolean jj_3R_392() {
38907 if (jj_scan_token(OR)) return true;
38908 if (jj_3R_391()) return true;
38909 return false;
38910 }
38911
38912 private boolean jj_3R_342() {
38913 if (jj_3R_391()) return true;
38914 Token xsp;
38915 while (true) {
38916 xsp = jj_scanpos;
38917 if (jj_3R_392()) { jj_scanpos = xsp; break; }
38918 }
38919 return false;
38920 }
38921
38922 private boolean jj_3R_235() {
38923 if (jj_scan_token(3)) return true;
38924 if (jj_3R_232()) return true;
38925 return false;
38926 }
38927
38928 private boolean jj_3R_233() {
38929 if (jj_scan_token(AT)) return true;
38930 if (jj_scan_token(TIME)) return true;
38931 if (jj_scan_token(ZONE)) return true;
38932 if (jj_3R_132()) return true;
38933 return false;
38934 }
38935
38936 private boolean jj_3R_138() {
38937 Token xsp;
38938 xsp = jj_scanpos;
38939 if (jj_scan_token(387)) {
38940 jj_scanpos = xsp;
38941 if (jj_scan_token(388)) return true;
38942 }
38943 if (jj_scan_token(5)) return true;
38944 if (jj_3R_232()) return true;
38945 xsp = jj_scanpos;
38946 if (jj_3R_233()) jj_scanpos = xsp;
38947 if (jj_scan_token(AS)) return true;
38948 if (jj_3R_234()) return true;
38949 if (jj_scan_token(7)) return true;
38950 while (true) {
38951 xsp = jj_scanpos;
38952 if (jj_3R_235()) { jj_scanpos = xsp; break; }
38953 }
38954 return false;
38955 }
38956
38957 private boolean jj_3R_114() {
38958 Token xsp;
38959 xsp = jj_scanpos;
38960 if (jj_scan_token(2)) {
38961 jj_scanpos = xsp;
38962 if (jj_scan_token(374)) {
38963 jj_scanpos = xsp;
38964 if (jj_scan_token(73)) {
38965 jj_scanpos = xsp;
38966 if (jj_scan_token(77)) {
38967 jj_scanpos = xsp;
38968 if (jj_scan_token(376)) {
38969 jj_scanpos = xsp;
38970 if (jj_scan_token(377)) {
38971 jj_scanpos = xsp;
38972 if (jj_scan_token(378)) {
38973 jj_scanpos = xsp;
38974 if (jj_scan_token(110)) {
38975 jj_scanpos = xsp;
38976 if (jj_scan_token(112)) {
38977 jj_scanpos = xsp;
38978 if (jj_scan_token(379)) {
38979 jj_scanpos = xsp;
38980 if (jj_scan_token(380)) {
38981 jj_scanpos = xsp;
38982 if (jj_scan_token(218)) {
38983 jj_scanpos = xsp;
38984 if (jj_scan_token(381)) {
38985 jj_scanpos = xsp;
38986 if (jj_scan_token(382)) {
38987 jj_scanpos = xsp;
38988 if (jj_scan_token(250)) {
38989 jj_scanpos = xsp;
38990 if (jj_scan_token(291)) {
38991 jj_scanpos = xsp;
38992 if (jj_scan_token(292)) {
38993 jj_scanpos = xsp;
38994 if (jj_scan_token(258)) {
38995 jj_scanpos = xsp;
38996 if (jj_scan_token(383)) {
38997 jj_scanpos = xsp;
38998 if (jj_scan_token(384)) {
38999 jj_scanpos = xsp;
39000 if (jj_scan_token(385)) {
39001 jj_scanpos = xsp;
39002 if (jj_scan_token(74)) {
39003 jj_scanpos = xsp;
39004 if (jj_scan_token(128)) {
39005 jj_scanpos = xsp;
39006 if (jj_scan_token(237)) {
39007 jj_scanpos = xsp;
39008 if (jj_scan_token(98)) {
39009 jj_scanpos = xsp;
39010 if (jj_scan_token(417)) {
39011 jj_scanpos = xsp;
39012 if (jj_3R_187()) return true;
39013 }
39014 }
39015 }
39016 }
39017 }
39018 }
39019 }
39020 }
39021 }
39022 }
39023 }
39024 }
39025 }
39026 }
39027 }
39028 }
39029 }
39030 }
39031 }
39032 }
39033 }
39034 }
39035 }
39036 }
39037 }
39038 }
39039 if (jj_3R_188()) return true;
39040 return false;
39041 }
39042
39043 private boolean jj_3R_227() {
39044 if (jj_3R_228()) return true;
39045 return false;
39046 }
39047
39048 private boolean jj_3R_226() {
39049 Token xsp;
39050 xsp = jj_scanpos;
39051 if (jj_scan_token(396)) {
39052 jj_scanpos = xsp;
39053 if (jj_scan_token(397)) {
39054 jj_scanpos = xsp;
39055 if (jj_scan_token(392)) return true;
39056 }
39057 }
39058 return false;
39059 }
39060
39061 private boolean jj_3R_113() {
39062 if (jj_3R_185()) return true;
39063 if (jj_3R_186()) return true;
39064 return false;
39065 }
39066
39067 private boolean jj_3_13() {
39068 if (jj_3R_114()) return true;
39069 return false;
39070 }
39071
39072 private boolean jj_3R_136() {
39073 if (jj_scan_token(TRIM)) return true;
39074 if (jj_scan_token(5)) return true;
39075 Token xsp;
39076 xsp = jj_scanpos;
39077 if (jj_3R_226()) jj_scanpos = xsp;
39078 xsp = jj_scanpos;
39079 if (jj_3R_227()) jj_scanpos = xsp;
39080 if (jj_scan_token(FROM)) return true;
39081 if (jj_3R_228()) return true;
39082 if (jj_scan_token(7)) return true;
39083 return false;
39084 }
39085
39086 private boolean jj_3_12() {
39087 if (jj_3R_113()) return true;
39088 return false;
39089 }
39090
39091 private boolean jj_3_11() {
39092 if (jj_3R_112()) return true;
39093 return false;
39094 }
39095
39096 private boolean jj_3_10() {
39097 if (jj_3R_111()) return true;
39098 return false;
39099 }
39100
39101 private boolean jj_3_9() {
39102 if (jj_3R_110()) return true;
39103 return false;
39104 }
39105
39106 private boolean jj_3_8() {
39107 if (jj_3R_109()) return true;
39108 return false;
39109 }
39110
39111 private boolean jj_3_7() {
39112 if (jj_3R_108()) return true;
39113 return false;
39114 }
39115
39116 private boolean jj_3_6() {
39117 if (jj_3R_107()) return true;
39118 return false;
39119 }
39120
39121 private boolean jj_3_5() {
39122 if (jj_3R_106()) return true;
39123 return false;
39124 }
39125
39126 private boolean jj_3_4() {
39127 if (jj_3R_105()) return true;
39128 return false;
39129 }
39130
39131 private boolean jj_3_3() {
39132 if (jj_3R_104()) return true;
39133 return false;
39134 }
39135
39136 private boolean jj_3_2() {
39137 if (jj_3R_103()) return true;
39138 return false;
39139 }
39140
39141 private boolean jj_3_1() {
39142 if (jj_3R_102()) return true;
39143 return false;
39144 }
39145
39146 private boolean jj_3R_231() {
39147 if (jj_scan_token(ELSE)) return true;
39148 if (jj_3R_232()) return true;
39149 return false;
39150 }
39151
39152 private boolean jj_3R_230() {
39153 if (jj_scan_token(WHEN)) return true;
39154 if (jj_3R_232()) return true;
39155 if (jj_scan_token(THEN)) return true;
39156 if (jj_3R_232()) return true;
39157 return false;
39158 }
39159
39160 private boolean jj_3R_229() {
39161 if (jj_3R_232()) return true;
39162 return false;
39163 }
39164
39165 private boolean jj_3R_137() {
39166 if (jj_scan_token(CASE)) return true;
39167 Token xsp;
39168 xsp = jj_scanpos;
39169 if (jj_3R_229()) jj_scanpos = xsp;
39170 if (jj_3R_230()) return true;
39171 while (true) {
39172 xsp = jj_scanpos;
39173 if (jj_3R_230()) { jj_scanpos = xsp; break; }
39174 }
39175 xsp = jj_scanpos;
39176 if (jj_3R_231()) jj_scanpos = xsp;
39177 if (jj_scan_token(END)) return true;
39178 return false;
39179 }
39180
39181 private boolean jj_3R_341() {
39182 if (jj_3R_132()) return true;
39183 if (jj_scan_token(9)) return true;
39184 if (jj_scan_token(10)) return true;
39185 if (jj_3R_232()) return true;
39186 return false;
39187 }
39188
39189 private boolean jj_3R_394() {
39190 if (jj_scan_token(CC_ELSE)) return true;
39191 if (jj_3R_232()) return true;
39192 return false;
39193 }
39194
39195 private boolean jj_3R_393() {
39196 if (jj_scan_token(CC_ELSIF)) return true;
39197 if (jj_3R_342()) return true;
39198 if (jj_scan_token(CC_THEN)) return true;
39199 if (jj_3R_232()) return true;
39200 return false;
39201 }
39202
39203 private boolean jj_3R_343() {
39204 if (jj_scan_token(CC_IF)) return true;
39205 if (jj_3R_342()) return true;
39206 if (jj_scan_token(CC_THEN)) return true;
39207 if (jj_3R_232()) return true;
39208 Token xsp;
39209 while (true) {
39210 xsp = jj_scanpos;
39211 if (jj_3R_393()) { jj_scanpos = xsp; break; }
39212 }
39213 while (true) {
39214 xsp = jj_scanpos;
39215 if (jj_3R_394()) { jj_scanpos = xsp; break; }
39216 }
39217 if (jj_scan_token(CC_END)) return true;
39218 return false;
39219 }
39220
39221 private boolean jj_3_45() {
39222 if (jj_3R_132()) return true;
39223 if (jj_scan_token(9)) return true;
39224 if (jj_scan_token(10)) return true;
39225 return false;
39226 }
39227
39228 private boolean jj_3R_301() {
39229 if (jj_3R_343()) return true;
39230 return false;
39231 }
39232
39233 private boolean jj_3R_300() {
39234 if (jj_3R_342()) return true;
39235 return false;
39236 }
39237
39238 private boolean jj_3R_299() {
39239 if (jj_3R_341()) return true;
39240 return false;
39241 }
39242
39243 private boolean jj_3R_232() {
39244 Token xsp;
39245 xsp = jj_scanpos;
39246 if (jj_3R_299()) {
39247 jj_scanpos = xsp;
39248 if (jj_3R_300()) {
39249 jj_scanpos = xsp;
39250 if (jj_3R_301()) return true;
39251 }
39252 }
39253 return false;
39254 }
39255
39256 private boolean jj_3R_108() {
39257 if (jj_scan_token(ALTER)) return true;
39258 if (jj_scan_token(TRIGGER)) return true;
39259 if (jj_3R_178()) return true;
39260 if (jj_scan_token(4)) return true;
39261 return false;
39262 }
39263
39264 private boolean jj_3R_317() {
39265 if (jj_3R_374()) return true;
39266 return false;
39267 }
39268
39269 private boolean jj_3R_419() {
39270 if (jj_3R_197()) return true;
39271 return false;
39272 }
39273
39274 private boolean jj_3R_121() {
39275 if (jj_3R_197()) return true;
39276 return false;
39277 }
39278
39279 private boolean jj_3R_316() {
39280 if (jj_3R_185()) return true;
39281 return false;
39282 }
39283
39284 private boolean jj_3R_266() {
39285 Token xsp;
39286 xsp = jj_scanpos;
39287 if (jj_3R_316()) {
39288 jj_scanpos = xsp;
39289 if (jj_3R_317()) return true;
39290 }
39291 return false;
39292 }
39293
39294 private boolean jj_3R_496() {
39295 if (jj_scan_token(IS)) return true;
39296 Token xsp;
39297 while (true) {
39298 xsp = jj_scanpos;
39299 if (jj_scan_token(5)) { jj_scanpos = xsp; break; }
39300 }
39301 if (jj_3R_400()) return true;
39302 return false;
39303 }
39304
39305 private boolean jj_3R_495() {
39306 if (jj_scan_token(RETURN)) return true;
39307 if (jj_3R_234()) return true;
39308 return false;
39309 }
39310
39311 private boolean jj_3R_494() {
39312 if (jj_3R_382()) return true;
39313 return false;
39314 }
39315
39316 private boolean jj_3R_197() {
39317 if (jj_scan_token(CURSOR)) return true;
39318 if (jj_3R_123()) return true;
39319 Token xsp;
39320 xsp = jj_scanpos;
39321 if (jj_3R_494()) jj_scanpos = xsp;
39322 xsp = jj_scanpos;
39323 if (jj_3R_495()) jj_scanpos = xsp;
39324 xsp = jj_scanpos;
39325 if (jj_3R_496()) jj_scanpos = xsp;
39326 if (jj_scan_token(4)) return true;
39327 return false;
39328 }
39329
39330 private boolean jj_3R_374() {
39331 Token xsp;
39332 xsp = jj_scanpos;
39333 if (jj_scan_token(358)) {
39334 jj_scanpos = xsp;
39335 if (jj_scan_token(357)) {
39336 jj_scanpos = xsp;
39337 if (jj_scan_token(352)) {
39338 jj_scanpos = xsp;
39339 if (jj_scan_token(351)) {
39340 jj_scanpos = xsp;
39341 if (jj_scan_token(356)) {
39342 jj_scanpos = xsp;
39343 if (jj_scan_token(361)) return true;
39344 }
39345 }
39346 }
39347 }
39348 }
39349 return false;
39350 }
39351
39352 private boolean jj_3R_272() {
39353 if (jj_scan_token(DISASSOCIATE)) return true;
39354 if (jj_scan_token(STATISTICS)) return true;
39355 return false;
39356 }
39357
39358 private boolean jj_3_83() {
39359 if (jj_3R_123()) return true;
39360 if (jj_scan_token(3)) return true;
39361 return false;
39362 }
39363
39364 private boolean jj_3R_557() {
39365 if (jj_3R_181()) return true;
39366 return false;
39367 }
39368
39369 private boolean jj_3R_622() {
39370 if (jj_3R_181()) return true;
39371 return false;
39372 }
39373
39374 private boolean jj_3R_271() {
39375 if (jj_scan_token(ASSOCIATE)) return true;
39376 if (jj_scan_token(STATISTICS)) return true;
39377 return false;
39378 }
39379
39380 private boolean jj_3R_185() {
39381 Token xsp;
39382 xsp = jj_scanpos;
39383 if (jj_scan_token(46)) {
39384 jj_scanpos = xsp;
39385 if (jj_scan_token(341)) {
39386 jj_scanpos = xsp;
39387 if (jj_3R_271()) {
39388 jj_scanpos = xsp;
39389 if (jj_scan_token(343)) {
39390 jj_scanpos = xsp;
39391 if (jj_scan_token(74)) {
39392 jj_scanpos = xsp;
39393 if (jj_scan_token(82)) {
39394 jj_scanpos = xsp;
39395 if (jj_3R_272()) {
39396 jj_scanpos = xsp;
39397 if (jj_scan_token(98)) {
39398 jj_scanpos = xsp;
39399 if (jj_scan_token(128)) {
39400 jj_scanpos = xsp;
39401 if (jj_scan_token(354)) {
39402 jj_scanpos = xsp;
39403 if (jj_scan_token(230)) {
39404 jj_scanpos = xsp;
39405 if (jj_scan_token(237)) {
39406 jj_scanpos = xsp;
39407 if (jj_scan_token(362)) {
39408 jj_scanpos = xsp;
39409 if (jj_scan_token(347)) return true;
39410 }
39411 }
39412 }
39413 }
39414 }
39415 }
39416 }
39417 }
39418 }
39419 }
39420 }
39421 }
39422 }
39423 return false;
39424 }
39425
39426 private boolean jj_3R_556() {
39427 if (jj_3R_181()) return true;
39428 return false;
39429 }
39430
39431 private boolean jj_3R_420() {
39432 if (jj_scan_token(IDENTIFIER)) return true;
39433 return false;
39434 }
39435
39436 private boolean jj_3_78() {
39437 if (jj_3R_123()) return true;
39438 if (jj_scan_token(3)) return true;
39439 return false;
39440 }
39441
39442 private boolean jj_3_82() {
39443 if (jj_3R_121()) return true;
39444 return false;
39445 }
39446
39447 private boolean jj_3R_268() {
39448 if (jj_3R_266()) return true;
39449 return false;
39450 }
39451
39452 private boolean jj_3_81() {
39453 if (jj_3R_120()) return true;
39454 return false;
39455 }
39456
39457
39458 public PLSQLParserTokenManager token_source;
39459 SimpleCharStream jj_input_stream;
39460
39461 public Token token;
39462
39463 public Token jj_nt;
39464 private Token jj_scanpos, jj_lastpos;
39465 private int jj_la;
39466 private int jj_gen;
39467 final private int[] jj_la1 = new int[447];
39468 static private int[] jj_la1_0;
39469 static private int[] jj_la1_1;
39470 static private int[] jj_la1_2;
39471 static private int[] jj_la1_3;
39472 static private int[] jj_la1_4;
39473 static private int[] jj_la1_5;
39474 static private int[] jj_la1_6;
39475 static private int[] jj_la1_7;
39476 static private int[] jj_la1_8;
39477 static private int[] jj_la1_9;
39478 static private int[] jj_la1_10;
39479 static private int[] jj_la1_11;
39480 static private int[] jj_la1_12;
39481 static private int[] jj_la1_13;
39482 static {
39483 jj_la1_init_0();
39484 jj_la1_init_1();
39485 jj_la1_init_2();
39486 jj_la1_init_3();
39487 jj_la1_init_4();
39488 jj_la1_init_5();
39489 jj_la1_init_6();
39490 jj_la1_init_7();
39491 jj_la1_init_8();
39492 jj_la1_init_9();
39493 jj_la1_init_10();
39494 jj_la1_init_11();
39495 jj_la1_init_12();
39496 jj_la1_init_13();
39497 }
39498 private static void jj_la1_init_0() {
39499 jj_la1_0 = new int[] {0x20000c,0x0,0x0,0x2,0xc,0x200000,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x8,0x0,0x8,0x0,0x0,0x40,0x0,0x0,0x8,0x40,0x8,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x10,0x0,0x0,0x100,0x200,0x200,0x0,0x20,0x0,0x20,0x0,0x40,0x0,0x0,0x0,0x200,0x200,0x4,0x0,0x800,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x230020,0x0,0x0,0x10,0x30020,0x230020,0x200000,0x30020,0x0,0x0,0x0,0x230020,0x230020,0x230020,0x230020,0x0,0x0,0x1000,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x0,0x0,0x1000,0x30020,0x0,0x30020,0x0,0x0,0x0,0x0,0x0,0x30020,0x40,0x0,0x0,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x230020,0x0,0x230020,0x0,0x230020,0x0,0x20,0x20,0x0,0x0,0x0,0x40,0x40,0x0,0x20,0x0,0x0,0x0,0x40,0x20,0x0,0x0,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x20,0x0,0x30020,0x0,0x0,0x30020,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x20,0x0,0x0,0x8,0x0,0x0,0x2400,0x2400,0xc000,0x8000,0xc000,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc000,0x0,0x0,0x70000,0x70000,0x40000,0x180002,0x180002,0x30000,0x30020,0x20,0x20,0x20,0x40,0x0,0x0,0x20,0x30020,0x0,0x2c,0x0,0x0,0x0,0x808,0x8,0x30020,0x40,0x800000,0x0,0x0,0x0,0x40,0x30000,0x30000,0x40,0x0,0x0,0x40,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x20,0x12,0x0,0x0,0x12,0x0,0x12,0x0,0x0,0x0,0x0,0x0,0x12,0x0,0x0,0x10,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x20,0x0,0x0,0x0,0x0,0x12,0x0,0x12,0x12,0x40,0x40,0x0,0x20,0x40,0x80,0x0,0x0,0x20,0x40,0x80,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x30000,0x30000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x230020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,};
39500 }
39501 private static void jj_la1_init_1() {
39502 jj_la1_1 = new int[] {0x1004000,0x0,0x0,0x0,0x0,0x0,0x0,0xa9721c38,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x30,0x400000,0x40000,0xfefffff8,0x40000,0x0,0x0,0x0,0x0,0x0,0x40000,0xa9721c38,0x0,0x1000000,0xfefffff8,0x40000,0x0,0x0,0xfefffff8,0xfefffff8,0xfefffff8,0x0,0xfefffff8,0xfefffff8,0x0,0xfefffff8,0xfefffff8,0x0,0x0,0x0,0x0,0x400000,0x30,0x0,0x0,0x0,0x0,0x0,0xfefffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x1000,0x40000,0xa9721c38,0x0,0xfefffff8,0xfffffff8,0x40000,0x441000,0x0,0x0,0xbc721c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfefffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa8721c38,0x0,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x14000000,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa9721c38,0xa9721c38,0x0,0x0,0x0,0xa9721c38,0xa9721c38,0x0,0xa8721c38,0x0,0x0,0x0,0xa9721c38,0xa9721c38,0xa9721c38,0xa9721c38,0x0,0x0,0x0,0xa9721c38,0x0,0xa9721c38,0x0,0xa9721c38,0x0,0x0,0x0,0x0,0xa8721c38,0x0,0xa8721c38,0xa8721c38,0x0,0xa8721c38,0x0,0xa8721c38,0xa8721c38,0x0,0x0,0x0,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa9721c38,0x0,0xa9721c38,0x0,0xa9721c38,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbc721c38,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa8721c38,0x0,0x0,0xa8721c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa8721c38,0x0,0x100000,0x0,0x0,0x8000,0x0,0x0,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x2000,0x2000,0x2000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa8721c38,0xa8721c38,0xa8721c38,0xa8721c38,0x0,0x0,0xa8721c38,0x0,0xa8721c38,0x0,0x100000,0x0,0x0,0x0,0x0,0x0,0xa8721c38,0x0,0x40000,0x0,0x0,0xfefffff8,0x0,0x0,0x0,0x0,0xa8721ff8,0x0,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xa8721c38,0xa8721c38,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0xa9721c38,0x0,0xfefffff8,0xfffffff8,0x40000,0x0,0x0,0x0,0x0,0x0,0x30,0x400000,0x40000,0x40000,0x0,0x0,0x0,0x40000,0x0,0x40000,0x0,0xfefffff8,0xfefffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x4000,0x0,0x0,0x800,0x0,0x800,0x0,0x0,0x0,0x200000,0x200000,0x0,0x0,0x0,0x200000,0x200000,0x800,0x30,0x400000,0x40000,0xfefffff8,0x0,0xfefffff8,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfefffff8,0x0,0x0,0x0,0x3c0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x0,0x0,0x4000,0x0,0xfefffff8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0xa9721c38,0x0,0x0,0xfefffff8,0x0,0x0,0xfefffff8,0x0,0x4000,0x0,0x4000,0xfefffff8,0x4000,0x0,0x4000,0x420de000,0xa0701c30,0xfefffff8,0xa8721c38,0xbcf21ff8,0x14420000,0x0,};
39503 }
39504 private static void jj_la1_init_2() {
39505 jj_la1_2 = new int[] {0x12042e00,0x10000800,0x10000800,0x0,0x2600,0x0,0x2000000,0x93eb8fa3,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0xbfffffff,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x93eb8fa3,0x0,0x0,0xbfffffff,0x0,0x0,0x248000,0xbfffffff,0xbfffffff,0xbfffffff,0x0,0xbfffffff,0xbfffffff,0x0,0xbfffffff,0xbfffffff,0x0,0x0,0x0,0x40000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x40,0xbfffffff,0x0,0x40,0x40,0x0,0x0,0x0,0x0,0x40000000,0x0,0x0,0x93eb8fa3,0x0,0xbfffffff,0xbfffffff,0x0,0x40000000,0x0,0x0,0x85eb8fad,0x8000000,0x8000000,0x48000,0x0,0x0,0x0,0x0,0x0,0xbfffffff,0x0,0x0,0x8000000,0x8000000,0x0,0x0,0x0,0x0,0x816b8fa1,0x0,0x0,0x0,0x0,0x4,0x0,0x4,0x0,0x480000c,0x0,0x0,0x4,0x0,0x0,0x0,0x800000,0x0,0x1000000,0x1000000,0x0,0x1000000,0x0,0x0,0x0,0x93eb8fa3,0x93eb8fa3,0x0,0x10000800,0x0,0x83eb8fa3,0x93eb8fa3,0x0,0x81eb8fa3,0x0,0x0,0x0,0x93eb8fa3,0x93eb8fa3,0x93eb8fa3,0x93eb8fa3,0x0,0x0,0x0,0x93eb8fa3,0x0,0x93eb8fa3,0x0,0x93eb8fa3,0x0,0x0,0x0,0x0,0x81eb8fa3,0x0,0x81eb8fa3,0x816b8fa1,0x0,0x816b8fa1,0x0,0x816b8fa1,0x81eb8fa3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x93eb8fa3,0x0,0x93eb8fa3,0x0,0x93eb8fa3,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x85eb8fad,0x0,0x0,0x0,0x8000000,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81eb8fa3,0x0,0x0,0x81eb8fa3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81eb8fa3,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81eb8fa3,0x81eb8fa3,0x81eb8fa3,0x81eb8fa3,0x0,0x800000,0x816b8fa1,0x0,0x81eb8fa3,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x81eb8fa3,0x0,0x0,0x0,0x0,0xbfffffff,0x0,0x0,0x0,0x0,0x816b8fa1,0x0,0x0,0x0,0x40,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x816b8fa1,0x816bafa1,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x40000000,0x0,0x0,0x0,0x0,0x0,0x93eb8fa3,0x0,0xbfffffff,0xbfffffff,0x0,0x0,0x0,0x0,0x40000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xbfffffff,0xbfffffff,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000,0x8000,0x0,0x0,0x0,0x8000,0x8000,0x0,0x0,0x0,0x0,0xbfffffff,0x0,0xbfffffff,0x0,0x0,0x0,0x0,0x20000,0x0,0x20000,0x0,0x0,0x1,0x1,0xbfffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000,0x0,0x10000000,0x0,0x10040400,0x0,0x10000000,0x0,0x10040400,0x0,0xbfffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x80000000,0x0,0x2000000,0x0,0x0,0x93eb8fa3,0x0,0x0,0xbfffffff,0x0,0x240000,0xbfffffff,0x0,0x40400,0x0,0x40400,0xbfffffff,0x40400,0x0,0x40400,0x3c843054,0x816b8fa1,0xbfffffff,0x816b8fa1,0x95fbcfad,0x4900004,0x0,};
39506 }
39507 private static void jj_la1_init_3() {
39508 jj_la1_3 = new int[] {0x10014004,0x0,0x0,0x0,0x14004,0x0,0x0,0x777f5698,0x800,0x0,0x0,0x8,0x8,0x0,0x0,0x0,0x0,0x0,0xfffffeff,0x0,0x0,0x8,0x8,0x0,0x0,0x0,0x777f5698,0x800,0x0,0xfffffeff,0x0,0x0,0x10400000,0xfffffeff,0xfffffeff,0xfffffeff,0x0,0xfffffeff,0xfffffeff,0x0,0xfffffeff,0xfffffeff,0x0,0x8,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffeff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x777f5698,0x800,0xfffffeff,0xfffffeff,0x0,0x0,0x0,0x0,0x34df1698,0x0,0x0,0x10400000,0x0,0x0,0x0,0x10000000,0x0,0xfffffeff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x345f1698,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x777f5698,0x777f5698,0x0,0x4000,0x0,0x777f5698,0x777f5698,0x0,0x345f1698,0x0,0x20,0x0,0x777f5698,0x777f5698,0x777f5698,0x777f5698,0x0,0x0,0x0,0x777f5698,0x0,0x777f5698,0x0,0x777f5698,0x40,0x20,0x0,0x0,0x345f1698,0x0,0x345f1698,0x345f1698,0x0,0x345f1698,0x0,0x345f1698,0x345f1698,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x777f5698,0x0,0x777f5698,0x0,0x777f5698,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x34df1698,0x0,0x0,0x0,0x0,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x345f1698,0x0,0x0,0x345f1698,0x0,0x20,0x0,0x200,0x0,0x0,0x0,0x345f1698,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x400,0x1,0x1,0x8000000,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x345f1698,0x345f1698,0x345f1698,0x345f1698,0x0,0x100000,0x345f1698,0x0,0x345f1698,0x0,0x0,0x100000,0x100000,0x0,0x0,0x0,0x345f1698,0x0,0x0,0x0,0x0,0xfffffeff,0x0,0x0,0x0,0x0,0x345f1698,0x0,0x0,0x0,0x0,0x0,0x0,0x10000000,0x10000000,0x0,0x10000000,0x10000000,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x345f1698,0x345f1698,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x777f5698,0x800,0xfffffeff,0xfffffeff,0x0,0x0,0x8,0x8,0x0,0x4000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffffeff,0xfffffeff,0x0,0x400000,0x0,0x0,0x400000,0x0,0x400000,0x0,0x0,0x0,0x0,0x0,0x4,0x0,0x0,0x0,0x0,0x0,0x400010,0x400010,0x0,0x0,0x0,0x400000,0x400000,0x4,0x0,0x0,0x0,0xfffffeff,0x0,0xfffffeff,0x0,0x400000,0x0,0x400000,0x0,0x0,0x0,0x4000000,0x4001000,0x0,0x0,0xfffffeff,0x0,0x0,0x0,0x0,0x0,0x8,0x8,0x0,0x1000000,0x0,0x0,0x4,0x0,0x0,0x0,0x4,0x0,0xfffffeff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0x80,0x0,0x0,0x0,0x0,0x777f5698,0x0,0x0,0xfffffeff,0x0,0x10000000,0xfffffeff,0x0,0x4,0x0,0x4,0xfffffeff,0x4,0x0,0x4,0x8980a025,0x345f1698,0xfffffeff,0x345f1698,0x36dfd6da,0x800000,0x0,};
39509 }
39510 private static void jj_la1_init_4() {
39511 jj_la1_4 = new int[] {0x20004001,0x20004000,0x20004000,0x0,0x1,0x0,0x0,0xaba8f4da,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0xfffff7de,0x400000,0x0,0x0,0x0,0x0,0x0,0x400000,0xaba8f4da,0x0,0x0,0xfffff7de,0x400000,0x0,0x8000,0xfffff7de,0xfffff7de,0xfffff7de,0x0,0xfffff7de,0xfffff7de,0x0,0xfffff7de,0xfffff7de,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffff7de,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0xaba8f4da,0x0,0xfffff7de,0xfffff7de,0x400000,0x400000,0x100,0x100,0xcba9b49a,0x0,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0xfffff7de,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8ba8b49a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40000000,0x40010000,0x0,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x10,0x10,0x0,0x10,0x0,0x0,0x0,0xaba8f4da,0xaba8f4da,0x0,0x20004000,0x0,0x8ba8b4da,0xaba8f4da,0x0,0x8ba8b49a,0x0,0x0,0x0,0xaba8f4da,0xaba8f4da,0xaba8f4da,0xaba8f4da,0x0,0x0,0x0,0xaba8f4da,0x0,0xaba8f4da,0x0,0xaba8f4da,0x0,0x0,0x400,0x0,0x8ba8b49a,0x0,0x8ba8b49a,0x8ba8b49a,0x0,0x8ba8b49a,0x0,0x8ba8b49a,0x8ba8b49a,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x100000,0x0,0x100,0x100,0x0,0x0,0x100,0x100,0x0,0x0,0x0,0x0,0xaba8f4da,0x0,0xaba8f4da,0x0,0xaba8f4da,0x0,0x0,0x0,0x0,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0xcba9b49a,0x0,0x0,0x0,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x8ba8b49a,0x0,0x0,0x8ba8b49a,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8ba8b49a,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x4000100,0x0,0x0,0x0,0x0,0x0,0x0,0x4000100,0x40000,0x0,0x0,0x4000100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8ba8b49a,0x8ba8b49a,0x8ba8b49a,0x8ba8b49a,0x0,0x80000,0x8ba8b49a,0x0,0x8ba8b49a,0x0,0x0,0x80000,0x0,0x0,0x0,0x0,0x8ba8b49a,0x0,0x0,0x0,0x0,0xfffff7de,0x0,0x0,0x0,0x0,0x8baab49a,0x2,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8ba8b49a,0x8ba8b49a,0x0,0x0,0x1000,0x1000,0x0,0x8000,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x0,0xaba8f4da,0x0,0xfffff7de,0xfffff7de,0x400000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x0,0x0,0x0,0x400000,0x0,0x400000,0x0,0xfffff7de,0xfffff7de,0x0,0x8000,0x0,0x0,0x8000,0x0,0x8000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8008000,0x8008000,0x0,0x0,0x0,0x8000,0x8000,0x0,0x0,0x0,0x400000,0xfffff7de,0x0,0xfffff7de,0x0,0x8000,0x0,0x8000,0x800,0x0,0x800,0x0,0x0,0x200000,0x200000,0xfffff7de,0x0,0x0,0x0,0x20000,0x0,0x0,0x0,0x0,0x0,0x4000,0x0,0x4001,0x0,0x4000,0x0,0x4001,0x0,0xfffff7de,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xaba8f4da,0x0,0x0,0xfffff7de,0x0,0x0,0xfffff7de,0x0,0x1,0x0,0x1,0xfffff7de,0x1,0x0,0x1,0x64554325,0xba8b49a,0xfffff7de,0x8ba8b49a,0xcbabb49a,0x40090010,0x0,};
39512 }
39513 private static void jj_la1_init_5() {
39514 jj_la1_5 = new int[] {0x8,0x8,0x8,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0x0,0x0,0x100000,0x100000,0x0,0x0,0x0,0x0,0x0,0xfffb7fff,0x0,0x0,0x100000,0x100000,0x0,0x0,0x0,0x81b2dbdf,0x0,0x0,0xfffb7fff,0x0,0x0,0x200005,0xfffb7fff,0xfffb7fff,0xfffb7fff,0x0,0xfffb7fff,0xfffb7fff,0x0,0xfffb7fff,0xfffb7fff,0x0,0x100000,0x100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffb7fff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0xfffb7fff,0xfffb7fff,0x0,0x0,0x0,0x0,0xff127bdf,0x0,0x0,0x200005,0x0,0x0,0x0,0x0,0x0,0xfffb7fff,0x200000,0xa00000,0x0,0x0,0x0,0x0,0x0,0x0,0x81125bdf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x7e003000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x840,0x840,0x0,0x840,0x0,0x0,0x0,0x81b2dbdf,0x81b2dbdf,0x0,0x8,0x0,0x81b2dbdf,0x81b2dbdf,0x0,0x81b2dbdf,0x0,0x0,0x0,0x81b2dbdf,0x81b2dbdf,0x81b2dbdf,0x81b2dbdf,0x0,0x0,0x0,0x81b2dbdf,0x0,0x81b2dbdf,0x0,0x81b2dbdf,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0x81b2dbdf,0x81125bdf,0x0,0x81125bdf,0x0,0x81125bdf,0x81b2dbdf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0x81b2dbdf,0x0,0x81b2dbdf,0x0,0x0,0x0,0x200000,0x0,0x7c000000,0x0,0x0,0x0,0x0,0x200000,0x0,0x0,0x0,0xff127bdf,0x0,0x200000,0xa00000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0x0,0x81b2dbdf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8192dbdf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200004,0x0,0x0,0x0,0x200000,0x4,0x0,0x4,0x0,0x0,0x0,0x200004,0x0,0x0,0x0,0x0,0x0,0x200,0x200,0x0,0x81b2dbdf,0x81b2dbdf,0x81925bdf,0x8192dbdf,0x0,0x800000,0x81125bdf,0x0,0x81b2dbdf,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0x0,0x0,0x0,0xfffb7fff,0x0,0x0,0x0,0x0,0x81125bdf,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200000,0xa00000,0x0,0x20000,0x20000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81125bdf,0x81125bdf,0x0,0x0,0x0,0x0,0x0,0x200000,0x200000,0x0,0x1,0x1,0x4,0x0,0x0,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0xfffb7fff,0xfffb7fff,0x0,0x0,0x100000,0x100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffb7fff,0xfffb7fff,0x0,0x200005,0x0,0x0,0xa00000,0x200000,0x800000,0x0,0x0,0x0,0x0,0x0,0x100,0x0,0x100,0x0,0x0,0x0,0x200005,0x200005,0x0,0x0,0x0,0x200005,0x200005,0x100,0x0,0x0,0x0,0xfffb7fff,0x0,0xfffb7fff,0x0,0xa00000,0x200000,0x800000,0x200000,0x200000,0x200000,0x0,0x0,0x0,0x0,0xfffb7fff,0x0,0x0,0x0,0x0,0x0,0x100000,0x100000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfffb7fff,0x4000,0x4000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x81b2dbdf,0x0,0x0,0xfffb7fff,0x0,0x0,0xfffb7fff,0x0,0x0,0x0,0x0,0xfffb7fff,0x0,0x0,0x0,0x2e40420,0x811259df,0xfffb7fff,0x81125bdf,0xff1b7bdf,0x7e003880,0x0,};
39515 }
39516 private static void jj_la1_init_6() {
39517 jj_la1_6 = new int[] {0x14004000,0x0,0x0,0x0,0x4000000,0x0,0x0,0xd9056c74,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff737fff,0x0,0x100,0x0,0x0,0x0,0x4000,0x0,0xd9056c74,0x0,0x0,0xff737fff,0x0,0x800000,0x10002200,0xfff37fff,0xfff37fff,0xfff37fff,0x0,0xfff37fff,0xfff37fff,0x0,0xfff37fff,0xfff37fff,0x100,0x0,0x0,0x0,0x88000,0x0,0x0,0x0,0x0,0x0,0x200,0xff737fff,0x0,0x200,0x200,0x0,0x0,0x0,0x0,0x88000,0x0,0x0,0xd9056c74,0x0,0xff737fff,0xfff37fff,0x0,0x88000,0x1000,0x0,0x99716c74,0x0,0x0,0x10002200,0x0,0x0,0x0,0x10000000,0x0,0xff737fff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x99016c74,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x700000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0xd9056c74,0xd9056c74,0x0,0x0,0x0,0xd9056c74,0xd9056c74,0x0,0x99016c74,0x0,0x0,0x0,0xd9056c74,0xd9056c74,0xd9056c74,0xd9056c74,0x0,0x0,0x0,0xd9056c74,0x0,0xd9056c74,0x0,0xd9056c74,0x0,0x0,0x0,0x0,0x99016c74,0x0,0x99016c74,0x99016c74,0x0,0x99016c74,0x0,0x99016c74,0x99016c74,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x1000,0x1000,0x0,0x1000,0x1000,0x1000,0x0,0x0,0x0,0x0,0xd9056c74,0x0,0xd9056c74,0x0,0xd9056c74,0x0,0x80000000,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x99716c74,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x99016c74,0x0,0x0,0x99016c74,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x99016c74,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x99016c74,0x99016c74,0x99016c74,0x99016c74,0x0,0x0,0x99016c74,0x0,0x99016c74,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x99016c74,0x0,0x0,0x0,0x0,0xff737fff,0x0,0x0,0x0,0x0,0x99016c74,0x80000000,0x0,0x80000000,0x200,0x0,0x200,0x10004000,0x10004000,0x0,0x10004000,0x10004000,0x0,0x0,0x1000000,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x100,0x20000000,0x0,0x100,0x0,0x0,0x20000000,0x99016c74,0x99016c74,0x0,0x0,0x40,0x40,0x0,0x2000,0x0,0x2000,0x200,0x200,0x0,0x0,0x8000,0x80000,0x0,0x0,0x0,0xd9056c74,0x0,0xff737fff,0xfff37fff,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xfff37fff,0xfff37fff,0x0,0x2200,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2200,0x2200,0x0,0x0,0x0,0x2200,0x2200,0x0,0x0,0x0,0x0,0xff737fff,0x0,0xff737fff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff737fff,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x100,0x0,0x0,0x0,0x0,0xff737fff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xd9056c74,0x0,0x0,0xfff37fff,0x800000,0x10000000,0xff737fff,0x0,0x0,0x100,0x0,0xff737fff,0x0,0x0,0x0,0x2202038a,0x91016c34,0xff737fff,0x99016c74,0xdff17c75,0x700001,0x0,};
39518 }
39519 private static void jj_la1_init_7() {
39520 jj_la1_7 = new int[] {0x4a06040,0xa04000,0xa04000,0x0,0x4002000,0x0,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc5f7dd7f,0x0,0x0,0xf7ffdd7f,0x0,0x0,0x0,0xf7ffdd7f,0xf7ffdd7f,0xf7ffdd7f,0x0,0xf7ffdd7f,0xf7ffdd7f,0x0,0xf7ffdd7f,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x20,0x200,0x0,0x0,0xc5f7dd7f,0x0,0xf7ffdd7f,0xf7ffdd7f,0x0,0x200,0x0,0x0,0xe577dd7f,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x80000,0x0,0x0,0xc577dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20001,0x2002000b,0x1000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400000,0x400000,0x0,0x400000,0x0,0x0,0x0,0xc5f7dd7f,0xc5f7dd7f,0x0,0x4a04000,0x0,0xc5f7dd7f,0xc5f7dd7f,0x0,0xc5f7dd7f,0x0,0x0,0x0,0xc5f7dd7f,0xc5f7dd7f,0xc5f7dd7f,0xc5f7dd7f,0x0,0x1000,0x0,0xc5f7dd7f,0x0,0xc5f7dd7f,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0xc5f7dd7f,0x100000,0xc5f7dd7f,0xc577dd7f,0x0,0xc577dd7f,0x0,0xc577dd7f,0xc5f7dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc00,0x0,0xc00,0xc5f7dd7f,0x0,0xc5f7dd7f,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0xe577dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x400,0x0,0x0,0xc5f7dd7f,0x0,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc5f7dd7f,0xc5f7dd7f,0xc5f7dd7f,0xc5f7dd7f,0x0,0x0,0xc577dd7f,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc5f7dd7f,0x0,0x0,0x0,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0xc577dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc577dd7f,0xc577dd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0xc5f7dd7f,0x0,0xf7ffdd7f,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffdd7f,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffdd7f,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2040,0x0,0x0,0x0,0x2040,0x0,0xf7ffdd7f,0x0,0x0,0x0,0x0,0x1000,0x1000,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc5f7dd7f,0x0,0x0,0xf7ffdd7f,0x0,0x0,0xf7ffdd7f,0x0,0x2040,0x0,0x2040,0xf7ffdd7f,0x2040,0x0,0x2040,0x3c802081,0x4577dd7e,0xf7ffdd7f,0xc577dd7f,0x677fdd7f,0x244e800f,0x0,};
39521 }
39522 private static void jj_la1_init_8() {
39523 jj_la1_8 = new int[] {0x2800004,0x0,0x0,0x0,0x4,0x0,0x0,0x2b5faceb,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x2b5faceb,0x0,0x0,0x2fffffff,0x0,0x0,0x8,0x2fffffff,0x2fffffff,0x2fffffff,0x0,0x2fffffff,0x2fffffff,0x0,0x2fffffff,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x0,0x2fffffff,0x0,0x20000000,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2b5faceb,0x0,0x2fffffff,0x2fffffff,0x0,0x0,0x0,0x0,0x2b5faceb,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x2000000,0x0,0x0,0x2b5faceb,0x0,0x0,0x1000,0x0,0x0,0x0,0x0,0x0,0x800,0x18000,0x0,0x0,0x0,0x0,0x200000,0x10000,0x0,0x0,0x0,0x0,0x0,0x200000,0x200000,0x0,0x2b5faceb,0x2b5faceb,0x80000000,0x0,0x0,0x2b5faceb,0x2b5faceb,0x0,0x2b5faceb,0x80000000,0x0,0x0,0x2b5faceb,0x2b5faceb,0x2b5faceb,0x2b5faceb,0x0,0x0,0x0,0x2b5faceb,0x0,0x2b5faceb,0x0,0x2b5faceb,0x0,0x0,0x40000000,0x0,0x6b5faceb,0x0,0x2b5faceb,0x2b5faceb,0x80000000,0x2b5faceb,0x80000000,0x2b5faceb,0x2b5faceb,0x0,0x20000000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x20000000,0x0,0x0,0x0,0x2b5faceb,0x0,0x2b5faceb,0x0,0x2b5faceb,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1000,0x0,0x0,0x0,0x0,0x0,0x2b5fbceb,0x2000020,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2b5faceb,0x0,0x0,0x2b5faceb,0x80000000,0x0,0x0,0x0,0x0,0x0,0x0,0x2b5faceb,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2b5faceb,0x2b5faceb,0x2b5faceb,0x2b5faceb,0x0,0x1010000,0x2b5faceb,0x0,0x2b5faceb,0x8000,0x0,0x1010000,0x1000000,0x0,0x0,0x0,0x2b5faceb,0x0,0x0,0x0,0x20000000,0x2fffffff,0x0,0x0,0x0,0x0,0x2b5faceb,0x0,0x0,0x0,0x0,0x0,0x0,0x2800000,0x2800000,0x0,0x2800000,0x2800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2b5faceb,0x2b5faceb,0x20000000,0x0,0x1000,0x1000,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x2b5faceb,0x0,0x2fffffff,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x8000000,0x0,0x2fffffff,0x2fffffff,0x0,0x8,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8,0x8,0x0,0x0,0x0,0x8,0x8,0x0,0x0,0x0,0x0,0x2fffffff,0x0,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2fffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80000000,0x0,0x0,0x0,0x2b5faceb,0x0,0x0,0x2fffffff,0x0,0x0,0x2fffffff,0x0,0x0,0x0,0x0,0x2fffffff,0x0,0x0,0x0,0x50a05204,0x295fa8e8,0x2fffffff,0x2b5faceb,0x2fdfaffb,0x1f9000,0x0,};
39524 }
39525 private static void jj_la1_init_9() {
39526 jj_la1_9 = new int[] {0x8000058,0x8000040,0x8000040,0x0,0x18,0x0,0x0,0xffffbe6e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffbe6e,0x0,0x0,0xffffffee,0x0,0x0,0x0,0xffffffee,0xffffffee,0xffffffee,0x0,0xffffffee,0xffffffee,0x0,0xffffffee,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffbe6e,0x0,0xffffffee,0xffffffee,0x0,0x0,0x0,0x0,0xf7ffffac,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffbe2c,0x0,0x0,0x180000,0x0,0x0,0x0,0x20000000,0x1878180,0x21e7f780,0x0,0x0,0x0,0x0,0x20000000,0x28000000,0x0,0x0,0x2000000,0x2000000,0x4000000,0x2000000,0x8000000,0x8000000,0x0,0xffffbe6e,0xffffbe6e,0x0,0x8000040,0x0,0xffffbe2e,0xffffbe6e,0x0,0xffffbe2c,0x0,0x0,0x0,0xffffbe6e,0xffffbe6e,0xffffbe6e,0xffffbe6e,0x0,0x0,0x0,0xffffbe6e,0x0,0xffffbe6e,0x0,0xffffbe6e,0x0,0x0,0x0,0x0,0xffffbe2c,0x0,0xffffbe2c,0xf7ffbe2c,0x0,0xf7ffbe2c,0x0,0xf7ffbe2c,0xffffbe2c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffbe6e,0x0,0xffffbe6e,0x0,0xffffbe6e,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x180000,0x0,0x0,0x0,0x0,0x0,0xf7ffffac,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0x8000000,0x0,0x0,0x0,0x0,0xffffbe2c,0x0,0x0,0xffffbe2c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffbe2c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffbe2c,0xffffbe2c,0xffffbe2c,0xffffbe2c,0x0,0x0,0xf7ffbe2c,0x0,0xffffbe2c,0x4000000,0x0,0x0,0x0,0x20,0x0,0x0,0xffffbe2c,0x0,0x0,0x0,0x0,0xffffffee,0x0,0x0,0x0,0x0,0xf7ffbe2c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xf7ffbe2c,0xf7ffbe2c,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffbe6e,0x0,0xffffffee,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffee,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffee,0x0,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0000000,0x40,0x0,0x40,0x0,0x40,0x0,0x40,0x0,0xffffffee,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0000000,0x0,0xffffbe6e,0xc0000000,0x0,0xffffffee,0xc0000000,0x0,0xffffffee,0xc0000000,0x0,0x0,0x0,0xffffffee,0x0,0x0,0x0,0x80001c1,0xf7fdae2c,0xffffffee,0xf7ffbe2c,0xf7ffffae,0x3fefff80,0x0,};
39527 }
39528 private static void jj_la1_init_10() {
39529 jj_la1_10 = new int[] {0x18e00000,0x0,0x0,0x0,0x0,0x0,0x0,0xffe01098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe01098,0x0,0x0,0xffe00018,0x0,0x0,0x80,0xffe00098,0xffe01098,0xffe01098,0x400,0xffe01098,0xffe01098,0x200,0xffe01098,0xffe01098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe01098,0x0,0xffe00018,0xffe00098,0x0,0x0,0x0,0x0,0xffe00098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xffe00018,0x400,0x200,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe01098,0xffe01098,0x0,0x0,0x0,0xffe01098,0xffe01098,0x0,0xffe00098,0x0,0x0,0x0,0xffe01098,0xffe01098,0xffe01098,0xffe01098,0x0,0x0,0x0,0xffe01098,0x0,0xffe01098,0x0,0xffe01098,0x0,0x0,0x0,0x0,0xffe00098,0x0,0xffe00098,0xffe00018,0x0,0xffe00018,0x0,0xffe00018,0xffe00098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe01098,0x400,0xffe01098,0x200,0xffe01098,0x1080,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00098,0x400,0x200,0xffe00098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x40,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0xffe00018,0xffe00018,0xffe00018,0x0,0x0,0xffe00018,0x0,0xffe00098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00098,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe01098,0x0,0xffe00018,0xffe00098,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffe00018,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x1,0x0,0x0,0x98e00000,0x0,0x0,0x0,0x98e00000,0x2000000,0xffe00018,0x18,0x18,0x4,0x2,0x0,0x0,0x0,0x40000000,0x0,0x40000000,0x0,0x0,0x0,0x5000000,0x1,0x20000000,0xffe01098,0x1,0x20000000,0xffe00019,0x1,0x0,0xffe00018,0x0,0x98e00000,0x0,0x98e00000,0xffe00018,0x18e00000,0x80000000,0x98e00000,0x60,0xffe00018,0xffe00018,0xffe00018,0xffe00018,0x0,0x0,};
39530 }
39531 private static void jj_la1_init_11() {
39532 jj_la1_11 = new int[] {0xff400404,0x0,0x0,0x0,0xff400000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x800000,0x0,0xffffffff,0x800,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x800,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x800800,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x13000,0x0,0x0,0x0,0x0,0x13000,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x0,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800,0xffffffff,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x675,0x0,0x0,0x0,0x675,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x80,0xffffffff,0x0,0x80,0xffffffff,0x0,0x0,0xffffffff,0x0,0x675,0x0,0x675,0xffffffff,0x404,0x271,0x675,0x0,0xffffffff,0xffffffff,0xffffffff,0xffffffff,0x800000,0x0,};
39533 }
39534 private static void jj_la1_init_12() {
39535 jj_la1_12 = new int[] {0x3,0x0,0x0,0x0,0x3,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x0,0x3f8ffff,0x3f8ffff,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x0,0x3f8ffff,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x3f8ffff,0x0,0x3f8ffff,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x3100,0x3100,0x3f8ffff,0x18,0x0,0x0,0x0,0x0,0x0,0x0,0xc00,0x0,0x0,0x0,0x0,0x800,0x0,0x800,0x0,0x0,0x0,0xc00,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x200,0x0,0x0,0x3f8ffff,0x0,0x0,0xc000,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x800000,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x20000,0x20000,0x60000,0x10000,0x0,0x10000,0x0,0x0,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x3f8ffff,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x3f8ffff,0x0,0x0,0x0,0x0,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x3f8ffff,0x0,0x0,};
39536 }
39537 private static void jj_la1_init_13() {
39538 jj_la1_13 = new int[] {0x2,0x0,0x0,0x0,0x2,0x0,0x0,0x2c6,0x0,0x2,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x0,0x3e02,0x0,0x0,0x2,0x3e02,0x3e02,0x3e02,0x0,0x3e02,0x3e02,0x0,0x3e02,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x3e02,0x3e02,0x0,0x0,0x0,0x0,0x202,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x202,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x2c6,0x0,0x0,0x0,0x2c6,0x2c6,0x0,0x2c6,0x0,0x0,0x2,0x2c6,0x2c6,0x2c6,0x2c6,0x2,0x0,0x0,0x2c6,0x2,0x2c6,0x2,0x2c6,0x0,0x0,0x0,0x0,0x2c6,0x0,0x2c6,0x202,0x0,0x202,0x0,0x202,0x2c6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x2c6,0x0,0x2c6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x202,0x0,0x0,0x0,0x0,0x0,0x2,0x0,0x0,0x282,0x282,0x0,0x282,0x0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x0,0x2c6,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xc0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x2c6,0x2c6,0x2c6,0x0,0xc4,0x202,0x0,0x2c6,0x0,0x0,0xc4,0x0,0x0,0x0,0x0,0x2c6,0x0,0x0,0x0,0x0,0x3e82,0x0,0x0,0x0,0x0,0x202,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x202,0x202,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x3e02,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x282,0x282,0x0,0x0,0x0,0x0,0x0,0x3e02,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e02,0x0,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e82,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x3e02,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x2c6,0x0,0x0,0x3e02,0x0,0x2,0x3e02,0x0,0x0,0x0,0x0,0x3e02,0x0,0x0,0x0,0x0,0x0,0x3e02,0x202,0x202,0x3c00,0x1c00,};
39539 }
39540 final private JJCalls[] jj_2_rtns = new JJCalls[83];
39541 private boolean jj_rescan = false;
39542 private int jj_gc = 0;
39543
39544
39545 public PLSQLParser(java.io.InputStream stream) {
39546 this(stream, null);
39547 }
39548
39549 public PLSQLParser(java.io.InputStream stream, String encoding) {
39550 try { jj_input_stream = new SimpleCharStream(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
39551 token_source = new PLSQLParserTokenManager(jj_input_stream);
39552 token = new Token();
39553 token.next = jj_nt = token_source.getNextToken();
39554 jj_gen = 0;
39555 for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39556 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39557 }
39558
39559
39560 public void ReInit(java.io.InputStream stream) {
39561 ReInit(stream, null);
39562 }
39563
39564 public void ReInit(java.io.InputStream stream, String encoding) {
39565 try { jj_input_stream.ReInit(stream, encoding, 1, 1); } catch(java.io.UnsupportedEncodingException e) { throw new RuntimeException(e); }
39566 token_source.ReInit(jj_input_stream);
39567 token = new Token();
39568 token.next = jj_nt = token_source.getNextToken();
39569 jjtree.reset();
39570 jj_gen = 0;
39571 for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39572 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39573 }
39574
39575
39576 public PLSQLParser(java.io.Reader stream) {
39577 jj_input_stream = new SimpleCharStream(stream, 1, 1);
39578 token_source = new PLSQLParserTokenManager(jj_input_stream);
39579 token = new Token();
39580 token.next = jj_nt = token_source.getNextToken();
39581 jj_gen = 0;
39582 for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39583 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39584 }
39585
39586
39587 public void ReInit(java.io.Reader stream) {
39588 jj_input_stream.ReInit(stream, 1, 1);
39589 token_source.ReInit(jj_input_stream);
39590 token = new Token();
39591 token.next = jj_nt = token_source.getNextToken();
39592 jjtree.reset();
39593 jj_gen = 0;
39594 for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39595 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39596 }
39597
39598
39599 public PLSQLParser(PLSQLParserTokenManager tm) {
39600 token_source = tm;
39601 token = new Token();
39602 token.next = jj_nt = token_source.getNextToken();
39603 jj_gen = 0;
39604 for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39605 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39606 }
39607
39608
39609 public void ReInit(PLSQLParserTokenManager tm) {
39610 token_source = tm;
39611 token = new Token();
39612 token.next = jj_nt = token_source.getNextToken();
39613 jjtree.reset();
39614 jj_gen = 0;
39615 for (int i = 0; i < 447; i++) jj_la1[i] = -1;
39616 for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();
39617 }
39618
39619 private Token jj_consume_token(int kind) throws ParseException {
39620 Token oldToken = token;
39621 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
39622 else jj_nt = jj_nt.next = token_source.getNextToken();
39623 if (token.kind == kind) {
39624 jj_gen++;
39625 if (++jj_gc > 100) {
39626 jj_gc = 0;
39627 for (int i = 0; i < jj_2_rtns.length; i++) {
39628 JJCalls c = jj_2_rtns[i];
39629 while (c != null) {
39630 if (c.gen < jj_gen) c.first = null;
39631 c = c.next;
39632 }
39633 }
39634 }
39635 return token;
39636 }
39637 jj_nt = token;
39638 token = oldToken;
39639 jj_kind = kind;
39640 throw generateParseException();
39641 }
39642
39643 static private final class LookaheadSuccess extends java.lang.Error { }
39644 final private LookaheadSuccess jj_ls = new LookaheadSuccess();
39645 private boolean jj_scan_token(int kind) {
39646 if (jj_scanpos == jj_lastpos) {
39647 jj_la--;
39648 if (jj_scanpos.next == null) {
39649 jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();
39650 } else {
39651 jj_lastpos = jj_scanpos = jj_scanpos.next;
39652 }
39653 } else {
39654 jj_scanpos = jj_scanpos.next;
39655 }
39656 if (jj_rescan) {
39657 int i = 0; Token tok = token;
39658 while (tok != null && tok != jj_scanpos) { i++; tok = tok.next; }
39659 if (tok != null) jj_add_error_token(kind, i);
39660 }
39661 if (jj_scanpos.kind != kind) return true;
39662 if (jj_la == 0 && jj_scanpos == jj_lastpos) throw jj_ls;
39663 return false;
39664 }
39665
39666
39667
39668 final public Token getNextToken() {
39669 if ((token = jj_nt).next != null) jj_nt = jj_nt.next;
39670 else jj_nt = jj_nt.next = token_source.getNextToken();
39671 jj_gen++;
39672 return token;
39673 }
39674
39675
39676 final public Token getToken(int index) {
39677 Token t = token;
39678 for (int i = 0; i < index; i++) {
39679 if (t.next != null) t = t.next;
39680 else t = t.next = token_source.getNextToken();
39681 }
39682 return t;
39683 }
39684
39685 private java.util.List<int[]> jj_expentries = new java.util.ArrayList<int[]>();
39686 private int[] jj_expentry;
39687 private int jj_kind = -1;
39688 private int[] jj_lasttokens = new int[100];
39689 private int jj_endpos;
39690
39691 private void jj_add_error_token(int kind, int pos) {
39692 if (pos >= 100) return;
39693 if (pos == jj_endpos + 1) {
39694 jj_lasttokens[jj_endpos++] = kind;
39695 } else if (jj_endpos != 0) {
39696 jj_expentry = new int[jj_endpos];
39697 for (int i = 0; i < jj_endpos; i++) {
39698 jj_expentry[i] = jj_lasttokens[i];
39699 }
39700 jj_entries_loop: for (java.util.Iterator<?> it = jj_expentries.iterator(); it.hasNext();) {
39701 int[] oldentry = (int[])(it.next());
39702 if (oldentry.length == jj_expentry.length) {
39703 for (int i = 0; i < jj_expentry.length; i++) {
39704 if (oldentry[i] != jj_expentry[i]) {
39705 continue jj_entries_loop;
39706 }
39707 }
39708 jj_expentries.add(jj_expentry);
39709 break jj_entries_loop;
39710 }
39711 }
39712 if (pos != 0) jj_lasttokens[(jj_endpos = pos) - 1] = kind;
39713 }
39714 }
39715
39716
39717 public ParseException generateParseException() {
39718 jj_expentries.clear();
39719 boolean[] la1tokens = new boolean[431];
39720 if (jj_kind >= 0) {
39721 la1tokens[jj_kind] = true;
39722 jj_kind = -1;
39723 }
39724 for (int i = 0; i < 447; i++) {
39725 if (jj_la1[i] == jj_gen) {
39726 for (int j = 0; j < 32; j++) {
39727 if ((jj_la1_0[i] & (1<<j)) != 0) {
39728 la1tokens[j] = true;
39729 }
39730 if ((jj_la1_1[i] & (1<<j)) != 0) {
39731 la1tokens[32+j] = true;
39732 }
39733 if ((jj_la1_2[i] & (1<<j)) != 0) {
39734 la1tokens[64+j] = true;
39735 }
39736 if ((jj_la1_3[i] & (1<<j)) != 0) {
39737 la1tokens[96+j] = true;
39738 }
39739 if ((jj_la1_4[i] & (1<<j)) != 0) {
39740 la1tokens[128+j] = true;
39741 }
39742 if ((jj_la1_5[i] & (1<<j)) != 0) {
39743 la1tokens[160+j] = true;
39744 }
39745 if ((jj_la1_6[i] & (1<<j)) != 0) {
39746 la1tokens[192+j] = true;
39747 }
39748 if ((jj_la1_7[i] & (1<<j)) != 0) {
39749 la1tokens[224+j] = true;
39750 }
39751 if ((jj_la1_8[i] & (1<<j)) != 0) {
39752 la1tokens[256+j] = true;
39753 }
39754 if ((jj_la1_9[i] & (1<<j)) != 0) {
39755 la1tokens[288+j] = true;
39756 }
39757 if ((jj_la1_10[i] & (1<<j)) != 0) {
39758 la1tokens[320+j] = true;
39759 }
39760 if ((jj_la1_11[i] & (1<<j)) != 0) {
39761 la1tokens[352+j] = true;
39762 }
39763 if ((jj_la1_12[i] & (1<<j)) != 0) {
39764 la1tokens[384+j] = true;
39765 }
39766 if ((jj_la1_13[i] & (1<<j)) != 0) {
39767 la1tokens[416+j] = true;
39768 }
39769 }
39770 }
39771 }
39772 for (int i = 0; i < 431; i++) {
39773 if (la1tokens[i]) {
39774 jj_expentry = new int[1];
39775 jj_expentry[0] = i;
39776 jj_expentries.add(jj_expentry);
39777 }
39778 }
39779 jj_endpos = 0;
39780 jj_rescan_token();
39781 jj_add_error_token(0, 0);
39782 int[][] exptokseq = new int[jj_expentries.size()][];
39783 for (int i = 0; i < jj_expentries.size(); i++) {
39784 exptokseq[i] = jj_expentries.get(i);
39785 }
39786 return new ParseException(token, exptokseq, tokenImage);
39787 }
39788
39789
39790 final public void enable_tracing() {
39791 }
39792
39793
39794 final public void disable_tracing() {
39795 }
39796
39797 private void jj_rescan_token() {
39798 jj_rescan = true;
39799 for (int i = 0; i < 83; i++) {
39800 try {
39801 JJCalls p = jj_2_rtns[i];
39802 do {
39803 if (p.gen > jj_gen) {
39804 jj_la = p.arg; jj_lastpos = jj_scanpos = p.first;
39805 switch (i) {
39806 case 0: jj_3_1(); break;
39807 case 1: jj_3_2(); break;
39808 case 2: jj_3_3(); break;
39809 case 3: jj_3_4(); break;
39810 case 4: jj_3_5(); break;
39811 case 5: jj_3_6(); break;
39812 case 6: jj_3_7(); break;
39813 case 7: jj_3_8(); break;
39814 case 8: jj_3_9(); break;
39815 case 9: jj_3_10(); break;
39816 case 10: jj_3_11(); break;
39817 case 11: jj_3_12(); break;
39818 case 12: jj_3_13(); break;
39819 case 13: jj_3_14(); break;
39820 case 14: jj_3_15(); break;
39821 case 15: jj_3_16(); break;
39822 case 16: jj_3_17(); break;
39823 case 17: jj_3_18(); break;
39824 case 18: jj_3_19(); break;
39825 case 19: jj_3_20(); break;
39826 case 20: jj_3_21(); break;
39827 case 21: jj_3_22(); break;
39828 case 22: jj_3_23(); break;
39829 case 23: jj_3_24(); break;
39830 case 24: jj_3_25(); break;
39831 case 25: jj_3_26(); break;
39832 case 26: jj_3_27(); break;
39833 case 27: jj_3_28(); break;
39834 case 28: jj_3_29(); break;
39835 case 29: jj_3_30(); break;
39836 case 30: jj_3_31(); break;
39837 case 31: jj_3_32(); break;
39838 case 32: jj_3_33(); break;
39839 case 33: jj_3_34(); break;
39840 case 34: jj_3_35(); break;
39841 case 35: jj_3_36(); break;
39842 case 36: jj_3_37(); break;
39843 case 37: jj_3_38(); break;
39844 case 38: jj_3_39(); break;
39845 case 39: jj_3_40(); break;
39846 case 40: jj_3_41(); break;
39847 case 41: jj_3_42(); break;
39848 case 42: jj_3_43(); break;
39849 case 43: jj_3_44(); break;
39850 case 44: jj_3_45(); break;
39851 case 45: jj_3_46(); break;
39852 case 46: jj_3_47(); break;
39853 case 47: jj_3_48(); break;
39854 case 48: jj_3_49(); break;
39855 case 49: jj_3_50(); break;
39856 case 50: jj_3_51(); break;
39857 case 51: jj_3_52(); break;
39858 case 52: jj_3_53(); break;
39859 case 53: jj_3_54(); break;
39860 case 54: jj_3_55(); break;
39861 case 55: jj_3_56(); break;
39862 case 56: jj_3_57(); break;
39863 case 57: jj_3_58(); break;
39864 case 58: jj_3_59(); break;
39865 case 59: jj_3_60(); break;
39866 case 60: jj_3_61(); break;
39867 case 61: jj_3_62(); break;
39868 case 62: jj_3_63(); break;
39869 case 63: jj_3_64(); break;
39870 case 64: jj_3_65(); break;
39871 case 65: jj_3_66(); break;
39872 case 66: jj_3_67(); break;
39873 case 67: jj_3_68(); break;
39874 case 68: jj_3_69(); break;
39875 case 69: jj_3_70(); break;
39876 case 70: jj_3_71(); break;
39877 case 71: jj_3_72(); break;
39878 case 72: jj_3_73(); break;
39879 case 73: jj_3_74(); break;
39880 case 74: jj_3_75(); break;
39881 case 75: jj_3_76(); break;
39882 case 76: jj_3_77(); break;
39883 case 77: jj_3_78(); break;
39884 case 78: jj_3_79(); break;
39885 case 79: jj_3_80(); break;
39886 case 80: jj_3_81(); break;
39887 case 81: jj_3_82(); break;
39888 case 82: jj_3_83(); break;
39889 }
39890 }
39891 p = p.next;
39892 } while (p != null);
39893 } catch(LookaheadSuccess ls) { }
39894 }
39895 jj_rescan = false;
39896 }
39897
39898 private void jj_save(int index, int xla) {
39899 JJCalls p = jj_2_rtns[index];
39900 while (p.gen > jj_gen) {
39901 if (p.next == null) { p = p.next = new JJCalls(); break; }
39902 p = p.next;
39903 }
39904 p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;
39905 }
39906
39907 static final class JJCalls {
39908 int gen;
39909 Token first;
39910 int arg;
39911 JJCalls next;
39912 }
39913
39914 }